method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
KafkaReceiver extends Thread implements AutoCloseable { public static ErrorHandler genericErrorLogger(Logger logger) { return cause -> logger.warn("Error processing Kafka record", cause); } KafkaReceiver(Consumer<K, V> consumer, long pollTimeoutMillis, String threadName,
RecordHandler<K, V> handler, ErrorHandler errorHandler); static ErrorHandler genericErrorLogger(Logger logger); @Override void run(); @Override void close(); void await(); }### Answer:
@Test public void testGenericErrorLogger() { when(consumer.poll(notNull())).then(split(() -> { throw new RuntimeException("boom"); })); final Logger logger = mock(Logger.class); receiver = new KafkaReceiver<String, String>(consumer, 1, "TestThread", recordHandler, KafkaReceiver.genericErrorLogger(logger)); SocketUtils.await().until(() -> { verify(recordHandler, never()).onReceive(any()); verify(logger, atLeastOnce()).warn(anyString(), any(RuntimeException.class)); }); } |
### Question:
ScramjetSerializer implements Serializer<KafkaData> { @Override public byte[] serialize(String topic, KafkaData data) { if (data.isError()) throw new IllegalArgumentException("Cannot serialize an error"); final ScramjetMessage msg = toScramjet(data); final String json = msg.toJson(gson); return s.serialize(topic, json); } @Override void configure(Map<String, ?> configs, boolean isKey); @Override byte[] serialize(String topic, KafkaData data); @Override void close(); }### Answer:
@Test(expected=IllegalArgumentException.class) public void testSerializeError() { final KafkaData d = new KafkaData(new RuntimeException()); serializer.serialize("test", d); } |
### Question:
WSConfigServiceImpl implements WSConfigService { public String convertPackageToTargetNamespace(String packageName) { if (!StringUtils.isNotBlank(packageName)) { return ""; } String[] delimitedString = StringUtils.split(packageName, "."); List<String> revertedList = new ArrayList<String>(); String revertedString; for (int i = delimitedString.length - 1; i >= 0; i--) { revertedList.add(delimitedString[i]); } revertedString = collectionToDelimitedString(revertedList, ".", "", ""); revertedString = "http: return revertedString; } boolean install(WsType type); boolean publishClassAsWebService(JavaType className,
AnnotationMetadata annotationMetadata); String convertPackageToTargetNamespace(String packageName); void addToJava2wsPlugin(JavaType serviceClass, String serviceName,
String addressName, String fullyQualifiedTypeName); void installWsdl2javaPlugin(); boolean addImportLocation(String wsdlLocation, WsType type); boolean addWsdlLocation(String wsdlLocation, Document wsdlDocument); void disableWsdlLocation(); boolean importService(JavaType serviceClass, String wsdlLocation,
WsType type); void mvn(String parameters, String message); static String collectionToDelimitedString(List<String> coll,
String delim, String prefix, String suffix); MetadataService getMetadataService(); FileManager getFileManager(); ProjectOperations getProjectOperations(); SecurityService getSecurityService(); AnnotationsService getAnnotationsService(); MavenOperations getMavenOperations(); }### Answer:
@Test public void testConvertPackageToTargetNamespace() throws Exception { String packageName = "org.gvnix.service.roo.addon"; String targetNamespaceExpected = "http: String targetNamespaceResult; targetNamespaceResult = wSConfigServiceImpl .convertPackageToTargetNamespace(packageName); Validate.isTrue( targetNamespaceResult != null && targetNamespaceResult.length() != 0, "The method doesn't work properly."); assertTrue("The namespace is not well generated", targetNamespaceResult.contains(targetNamespaceExpected)); } |
### Question:
CamtUtil { public static boolean isMatchingXsdSchema(byte[] xmlAsBytes, @Nonnull String pathToXsd) { try (ByteArrayInputStream xmlAsStream = new ByteArrayInputStream(xmlAsBytes); InputStream xsdAsStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(pathToXsd)) { SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI); Schema schema = factory.newSchema(new StreamSource(xsdAsStream)); Validator validator = schema.newValidator(); validator.validate(new StreamSource(xmlAsStream)); return true; } catch (IOException e) { throw new Iso20022RuntimeException("IO Exception while validating xml file with xsd schema", e); } catch (SAXException ignore) { return false; } } private CamtUtil(); @Nonnull static CamtTypeVersion detectCamtTypeVersion(@Nonnull byte[] xmlAsBytes); static boolean isMatchingXsdSchema(byte[] xmlAsBytes, @Nonnull String pathToXsd); }### Answer:
@Test public void validateXmlWithXsdSuccessTest() { assertTrue(CamtUtil.isMatchingXsdSchema(readXml(VALID_CAMT53_XML), CAMT053V00104.getXsdPath())); assertTrue(CamtUtil.isMatchingXsdSchema(readXml(VALID_CAMT54_XML), CAMT054V00104.getXsdPath())); }
@Test public void validateXmlWithXsdFailureTest() { byte[] bytes = readXml(INVALID_XML); assertFalse(CamtUtil.isMatchingXsdSchema(bytes, CAMT054V00104.getXsdPath())); assertFalse(CamtUtil.isMatchingXsdSchema(readXml(VALID_CAMT53_XML), CAMT054V00104.getXsdPath())); assertFalse(CamtUtil.isMatchingXsdSchema(readXml(VALID_CAMT54_XML), CAMT053V00104.getXsdPath())); } |
### Question:
CamtUtil { @Nonnull public static CamtTypeVersion detectCamtTypeVersion(@Nonnull byte[] xmlAsBytes) throws Iso20022RuntimeException { return Arrays.stream(CamtTypeVersion.values()) .filter(type -> isMatchingXsdSchema(xmlAsBytes, type.getXsdPath())) .findAny() .orElseThrow(() -> new Iso20022RuntimeException("Cannot process input. XSD validation failed.")); } private CamtUtil(); @Nonnull static CamtTypeVersion detectCamtTypeVersion(@Nonnull byte[] xmlAsBytes); static boolean isMatchingXsdSchema(byte[] xmlAsBytes, @Nonnull String pathToXsd); }### Answer:
@Test public void detectDetectCamtTypeVersionTest() { assertEquals(CAMT053V00104, CamtUtil.detectCamtTypeVersion(readXml(VALID_CAMT53_XML))); assertEquals(CAMT054V00104, CamtUtil.detectCamtTypeVersion(readXml(VALID_CAMT54_XML))); } |
### Question:
FormatUtil { static int numberOfDigits(long l) { if (l == 0) { return 1; } return ((int) Math.ceil(Math.log10(l + 0.5))); } private FormatUtil(); static void padRight(StringBuilder buf, char c, int count); }### Answer:
@Test public void testNumberOfDigits() { assertThat(FormatUtil.numberOfDigits(0)).isEqualTo(1); assertThat(FormatUtil.numberOfDigits(1)).isEqualTo(1); assertThat(FormatUtil.numberOfDigits(5)).isEqualTo(1); assertThat(FormatUtil.numberOfDigits(10)).isEqualTo(2); assertThat(FormatUtil.numberOfDigits(99)).isEqualTo(2); assertThat(FormatUtil.numberOfDigits(100)).isEqualTo(3); assertThat(FormatUtil.numberOfDigits(1000)).isEqualTo(4); } |
### Question:
SizeBucket { public long[] computeBucketUpperBorders() { return getBucketModel().computeBucketUpperBorders(findMaxNumBucket()); } SizeBucket(); SizeBucket(BucketModel bucketModel); void add(long size); long[] computeBucketUpperBorders(); int findMaxNumBucket(); long getBucketCounter(int bucket); long[] get(); int size(); BucketModel getBucketModel(); @Override String toString(); }### Answer:
@Test public void testComputeBucketUpperBorders() { SizeBucket sizeBucket = new SizeBucket(); assertThat(sizeBucket.computeBucketUpperBorders()).isEqualTo(new long[]{0 }); sizeBucket.add(1024L); assertThat(sizeBucket.computeBucketUpperBorders()).isEqualTo(new long[]{0, 1024L * 1024L }); } |
### Question:
IECBinary { public static long parse(String formattedValue) { final Matcher matcher = PATTERN_VALUE_WITH_STORAGE_UNIT.matcher(formattedValue); if (!matcher.matches()) { throw new IllegalArgumentException("Expected pattern " + PATTERN_VALUE_WITH_STORAGE_UNIT.pattern() + " but got value <" + formattedValue + ">"); } long number = Long.parseLong(matcher.group(1)); String unit = matcher.group(2); if (null != unit) { for (int i = 0; i < UNITS.length; i++) { if (unit.equalsIgnoreCase(UNITS[i])) { number *= Math.pow(1024, i); break; } } } return number; } private IECBinary(); static String format(long numericalValue); static long parse(String formattedValue); }### Answer:
@Test public void testParse() { for (int i = 0; i < formattedValues.length; i++) { assertThat(IECBinary.parse(formattedValues[i])).isEqualTo(rawValues[i]); } assertThat(IECBinary.parse("0")).isEqualTo(0); assertThat(IECBinary.parse("0B")).isEqualTo(0); assertThat(IECBinary.parse("1 KiB")).isEqualTo(1024); for (String value : new String[]{"", " ", "KiB"}) { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> IECBinary.parse(value)); } } |
### Question:
IECBinary { public static String format(long numericalValue) { if (numericalValue < 1024) { return numericalValue + " B"; } int exp = (int) (Math.log(numericalValue) / Math.log(1024)); String pre = "KMGTPE".charAt(exp - 1) + "i"; return String.format("%.0f %sB", numericalValue / Math.pow(1024, exp), pre); } private IECBinary(); static String format(long numericalValue); static long parse(String formattedValue); }### Answer:
@Test public void testFormat() { for (int i = 0; i < formattedValues.length; i++) { assertThat(IECBinary.format(rawValues[i])).isEqualTo(formattedValues[i]); } assertThat(IECBinary.format(1024 + 512 - 1)).isEqualTo("1 KiB"); assertThat(IECBinary.format(1024 + 512)).isEqualTo("2 KiB"); } |
### Question:
SummaryReportCommand extends AbstractReportCommand { static List<UserStats> filterByUserName(Collection<UserStats> userStats, String userNamePattern) { List<UserStats> filtered = new ArrayList<>(userStats); if (null != userNamePattern && !userNamePattern.isEmpty()) { Pattern pattern = Pattern.compile(userNamePattern); filtered.removeIf(u -> !pattern.matcher(u.userName).find()); } return filtered; } @Override void run(); }### Answer:
@Test public void testFilter() { final List<UserStats> list = Arrays.asList(new UserStats("foobar"), new UserStats("foo_bar"), new UserStats("fo_obar"), new UserStats("nofoobar")); String userNameFilter = "^foo.*"; List<UserStats> filtered = filterByUserName(list, userNameFilter); assertThat(filtered.size()).isEqualTo(2); assertThat(filtered.get(0).userName).isEqualTo("foobar"); assertThat(filtered.get(1).userName).isEqualTo("foo_bar"); userNameFilter = "foo.*"; filtered = filterByUserName(list, userNameFilter); assertThat(filtered).extracting(userStats -> userStats.userName) .isEqualTo(Arrays.asList("foobar", "foo_bar", "nofoobar")); userNameFilter = ".*bar.*"; filtered = filterByUserName(list, userNameFilter); assertThat(filtered).isEqualTo(list); } |
### Question:
UserMetricsController implements UserMetricsApiDelegate { @VisibleForTesting public boolean hasValidBlobIdIfNotebookNamePresent(DbUserRecentResource dbUserRecentResource) { return Optional.ofNullable(dbUserRecentResource.getNotebookName()) .map(name -> uriToBlobId(name).isPresent()) .orElse(true); } @Autowired UserMetricsController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserRecentResourceService userRecentResourceService,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
CloudStorageService cloudStorageService,
CommonMappers commonMappers,
FirecloudMapper firecloudMapper); @VisibleForTesting void setDistinctWorkspaceLimit(int limit); @Override ResponseEntity<WorkspaceResource> updateRecentResource(
String workspaceNamespace, String workspaceId, RecentResourceRequest recentResourceRequest); @Override ResponseEntity<EmptyResponse> deleteRecentResource(
String workspaceNamespace, String workspaceId, RecentResourceRequest recentResourceRequest); @Override ResponseEntity<WorkspaceResourceResponse> getUserRecentResources(); @VisibleForTesting boolean hasValidBlobIdIfNotebookNamePresent(DbUserRecentResource dbUserRecentResource); }### Answer:
@Test public void testHasValidBlobIdIfNotebookNamePresent_nullNotebookName_passes() { dbUserRecentResource1.setNotebookName(null); assertTrue(userMetricsController.hasValidBlobIdIfNotebookNamePresent(dbUserRecentResource1)); }
@Test public void testHasValidBlobIdIfNotebookNamePresent_validNotebookName_passes() { assertTrue(userMetricsController.hasValidBlobIdIfNotebookNamePresent(dbUserRecentResource1)); }
@Test public void testHasValidBlobIdIfNotebookNamePresent_invalidNotebookName_fails() { dbUserRecentResource1.setNotebookName("invalid-notebook@name"); assertFalse(userMetricsController.hasValidBlobIdIfNotebookNamePresent(dbUserRecentResource1)); } |
### Question:
AuthDomainController implements AuthDomainApiDelegate { @AuthorityRequired({Authority.DEVELOPER}) @Override public ResponseEntity<EmptyResponse> createAuthDomain(String groupName) { fireCloudService.createGroup(groupName); return ResponseEntity.ok(new EmptyResponse()); } @Autowired AuthDomainController(
FireCloudService fireCloudService,
UserService userService,
UserDao userDao,
AuthDomainAuditor authDomainAuditAdapter); @AuthorityRequired({Authority.DEVELOPER}) @Override ResponseEntity<EmptyResponse> createAuthDomain(String groupName); @Override @AuthorityRequired({Authority.ACCESS_CONTROL_ADMIN}) ResponseEntity<Void> updateUserDisabledStatus(UpdateUserDisabledRequest request); }### Answer:
@Test public void testCreateAuthDomain() { ResponseEntity<EmptyResponse> response = this.authDomainController.createAuthDomain(""); assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); } |
### Question:
WorkspaceAdminController implements WorkspaceAdminApiDelegate { @Override @AuthorityRequired({Authority.RESEARCHER_DATA_VIEW}) public ResponseEntity<WorkspaceAdminView> getWorkspaceAdminView(String workspaceNamespace) { return ResponseEntity.ok(workspaceAdminService.getWorkspaceAdminView(workspaceNamespace)); } @Autowired WorkspaceAdminController(WorkspaceAdminService workspaceAdminService); @Override @AuthorityRequired({Authority.RESEARCHER_DATA_VIEW}) ResponseEntity<CloudStorageTraffic> getCloudStorageTraffic(String workspaceNamespace); @Override @AuthorityRequired({Authority.RESEARCHER_DATA_VIEW}) ResponseEntity<WorkspaceAdminView> getWorkspaceAdminView(String workspaceNamespace); @Override @AuthorityRequired({Authority.RESEARCHER_DATA_VIEW}) ResponseEntity<WorkspaceAuditLogQueryResponse> getAuditLogEntries(
String workspaceNamespace,
Integer limit,
Long afterMillis,
@Nullable Long beforeMillisNullable); @Override @AuthorityRequired({Authority.RESEARCHER_DATA_VIEW}) ResponseEntity<ReadOnlyNotebookResponse> adminReadOnlyNotebook(
String workspaceNamespace, String notebookName, AccessReason accessReason); @Override @AuthorityRequired({Authority.RESEARCHER_DATA_VIEW}) ResponseEntity<List<FileDetail>> listFiles(String workspaceNamespace); }### Answer:
@Test(expected = NotFoundException.class) public void getWorkspaceAdminView_404sWhenNotFound() { doThrow( new NotFoundException( String.format("No workspace found for namespace %s", NONSENSE_NAMESPACE))) .when(mockWorkspaceAdminService) .getWorkspaceAdminView(NONSENSE_NAMESPACE); workspaceAdminController.getWorkspaceAdminView(NONSENSE_NAMESPACE); } |
### Question:
BillingProjectBufferService implements GaugeDataCollector { public BillingProjectBufferStatus getStatus() { final long bufferSize = billingProjectBufferEntryDao.countByStatus( DbStorageEnums.billingProjectBufferEntryStatusToStorage(BufferEntryStatus.AVAILABLE)); return new BillingProjectBufferStatus().bufferSize(bufferSize); } @Autowired BillingProjectBufferService(
BillingProjectBufferEntryDao billingProjectBufferEntryDao,
Clock clock,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider); void bufferBillingProjects(); @Override Collection<MeasurementBundle> getGaugeData(); void syncBillingProjectStatus(); void cleanBillingBuffer(); DbBillingProjectBufferEntry assignBillingProject(DbUser dbUser); BillingProjectBufferStatus getStatus(); }### Answer:
@Test public void testGetStatus() { final long numberAvailable = billingProjectBufferEntryDao.countByStatus( DbStorageEnums.billingProjectBufferEntryStatusToStorage(BufferEntryStatus.AVAILABLE)); final BillingProjectBufferStatus bufferStatus = billingProjectBufferService.getStatus(); assertThat(bufferStatus.getBufferSize()).isEqualTo(numberAvailable); } |
### Question:
BillingProjectBufferService implements GaugeDataCollector { @Override public Collection<MeasurementBundle> getGaugeData() { final ImmutableMap<BufferEntryStatus, Long> entryStatusToCount = ImmutableMap.copyOf(billingProjectBufferEntryDao.getCountByStatusMap()); return Arrays.stream(BufferEntryStatus.values()) .map( status -> MeasurementBundle.builder() .addMeasurement( GaugeMetric.BILLING_BUFFER_PROJECT_COUNT, entryStatusToCount.getOrDefault(status, 0L)) .addTag(MetricLabel.BUFFER_ENTRY_STATUS, status.toString()) .build()) .collect(Collectors.toList()); } @Autowired BillingProjectBufferService(
BillingProjectBufferEntryDao billingProjectBufferEntryDao,
Clock clock,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider); void bufferBillingProjects(); @Override Collection<MeasurementBundle> getGaugeData(); void syncBillingProjectStatus(); void cleanBillingBuffer(); DbBillingProjectBufferEntry assignBillingProject(DbUser dbUser); BillingProjectBufferStatus getStatus(); }### Answer:
@Test public void testGetGaugeData() { final Collection<MeasurementBundle> bundles = billingProjectBufferService.getGaugeData(); assertThat(bundles.size()).isGreaterThan(0); Optional<MeasurementBundle> entryStatusBundle = bundles.stream() .filter(b -> b.getMeasurements().containsKey(GaugeMetric.BILLING_BUFFER_PROJECT_COUNT)) .findFirst(); assertThat(entryStatusBundle.isPresent()).isTrue(); assertThat(entryStatusBundle.get().getTags()).isNotEmpty(); } |
### Question:
StatusAlertController implements StatusAlertApiDelegate { @Override public ResponseEntity<StatusAlert> getStatusAlert() { Optional<DbStatusAlert> dbStatusAlertOptional = statusAlertDao.findFirstByOrderByStatusAlertIdDesc(); if (dbStatusAlertOptional.isPresent()) { DbStatusAlert dbStatusAlert = dbStatusAlertOptional.get(); return ResponseEntity.ok(StatusAlertConversionUtils.toApiStatusAlert(dbStatusAlert)); } else { return ResponseEntity.ok(new StatusAlert()); } } @Autowired StatusAlertController(StatusAlertDao statusAlertDao); @Override ResponseEntity<StatusAlert> getStatusAlert(); @Override @AuthorityRequired(Authority.COMMUNICATIONS_ADMIN) ResponseEntity<StatusAlert> postStatusAlert(StatusAlert statusAlert); }### Answer:
@Test public void testGetStatusAlert() { StatusAlert statusAlert = statusAlertController.getStatusAlert().getBody(); assertThat(statusAlert.getTitle()).matches(STATUS_ALERT_INITIAL_TITLE); assertThat(statusAlert.getMessage()).matches(STATUS_ALERT_INITIAL_DESCRIPTION); } |
### Question:
StatusAlertController implements StatusAlertApiDelegate { @Override @AuthorityRequired(Authority.COMMUNICATIONS_ADMIN) public ResponseEntity<StatusAlert> postStatusAlert(StatusAlert statusAlert) { Iterable<DbStatusAlert> dbStatusAlertList = statusAlertDao.findAll(); dbStatusAlertList.forEach( statusAlert1 -> statusAlertDao.delete(statusAlert1.getStatusAlertId())); DbStatusAlert dbStatusAlert = statusAlertDao.save(StatusAlertConversionUtils.toDbStatusAlert(statusAlert)); return ResponseEntity.ok(StatusAlertConversionUtils.toApiStatusAlert(dbStatusAlert)); } @Autowired StatusAlertController(StatusAlertDao statusAlertDao); @Override ResponseEntity<StatusAlert> getStatusAlert(); @Override @AuthorityRequired(Authority.COMMUNICATIONS_ADMIN) ResponseEntity<StatusAlert> postStatusAlert(StatusAlert statusAlert); }### Answer:
@Test public void testPostStatusAlert() { String updatedStatusAlertTitle = "Title 2"; String updatedStatusAlertDescription = "Description 2"; String updatedStatusAlertLink = "This has a link"; StatusAlert statusAlert = new StatusAlert() .title(updatedStatusAlertTitle) .message(updatedStatusAlertDescription) .link(updatedStatusAlertLink); statusAlertController.postStatusAlert(statusAlert); StatusAlert updatedStatusAlert = statusAlertController.getStatusAlert().getBody(); assertThat(updatedStatusAlert.getTitle()).matches(updatedStatusAlertTitle); assertThat(updatedStatusAlert.getMessage()).matches(updatedStatusAlertDescription); assertThat(updatedStatusAlert.getLink()).matches(updatedStatusAlertLink); } |
### Question:
OfflineAuditController implements OfflineAuditApiDelegate { @VisibleForTesting static String auditTableSuffix(Instant now, int daysAgo) { Instant target = now.minus(daysAgo, ChronoUnit.DAYS); return auditTableNameDateFormatter.withZone(ZoneId.of("UTC")).format(target); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); @Override ResponseEntity<AuditBigQueryResponse> auditBigQuery(); }### Answer:
@Test public void testAuditTableSuffix() { assertThat(OfflineAuditController.auditTableSuffix(Instant.parse("2007-01-03T00:00:00.00Z"), 0)) .isEqualTo("20070103"); assertThat(OfflineAuditController.auditTableSuffix(Instant.parse("2018-01-01T23:59:59.00Z"), 3)) .isEqualTo("20171229"); } |
### Question:
ProfileService { public void validateNewProfile(Profile profile) throws BadRequestException { final Profile dummyProfile = null; validateProfileForCorrectness(dummyProfile, profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); }### Answer:
@Test(expected = BadRequestException.class) public void validateProfile_emptyNewObject() { profileService.validateNewProfile(new Profile()); } |
### Question:
FreeTierBillingService { public double getUserFreeTierDollarLimit(DbUser user) { return Optional.ofNullable(user.getFreeTierCreditsLimitDollarsOverride()) .orElse(workbenchConfigProvider.get().billing.defaultFreeCreditsDollarLimit); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); }### Answer:
@Test public void getUserFreeTierDollarLimit_default() { final DbUser user = createUser(SINGLE_WORKSPACE_TEST_USER); final double initialFreeCreditsDollarLimit = 1.0; workbenchConfig.billing.defaultFreeCreditsDollarLimit = initialFreeCreditsDollarLimit; assertWithinBillingTolerance( freeTierBillingService.getUserFreeTierDollarLimit(user), initialFreeCreditsDollarLimit); final double fractionalFreeCreditsDollarLimit = 123.456; workbenchConfig.billing.defaultFreeCreditsDollarLimit = fractionalFreeCreditsDollarLimit; assertWithinBillingTolerance( freeTierBillingService.getUserFreeTierDollarLimit(user), fractionalFreeCreditsDollarLimit); } |
### Question:
Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); }### Answer:
@Test public void itMatchesGroup() { final Optional<String> nextLetter = Matchers.getGroup(SINGLE_GROUP_PATTERN, "abcdf", GROUP_NAME); assertThat(nextLetter).hasValue("f"); }
@Test public void getGroup_noMatch() { final Optional<String> nextLetter = Matchers.getGroup(SINGLE_GROUP_PATTERN, "abcdk", GROUP_NAME); assertThat(nextLetter).isEmpty(); }
@Test public void testGetGroup_noSuchGroup() { final Optional<String> nextLetter = Matchers.getGroup(SINGLE_GROUP_PATTERN, "abcdk", "oops"); assertThat(nextLetter).isEmpty(); }
@Test public void testGetGroup_hyphens() { final Pattern VM_NAME_PATTERN = Pattern.compile("all-of-us-(?<userid>\\d+)-m"); final Optional<String> suffix = Matchers.getGroup(VM_NAME_PATTERN, "all-of-us-2222-m", "userid"); assertThat(suffix).hasValue("2222"); } |
### Question:
AuthInterceptor extends HandlerInterceptorAdapter { boolean hasRequiredAuthority(HandlerMethod handlerMethod, DbUser user) { return hasRequiredAuthority(InterceptorUtils.getControllerMethod(handlerMethod), user); } @Autowired AuthInterceptor(
UserInfoService userInfoService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
DevUserRegistrationService devUserRegistrationService); @Override boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler); @Override void postHandle(
HttpServletRequest request,
HttpServletResponse response,
Object handler,
ModelAndView modelAndView); }### Answer:
@Test public void authorityCheckPermitsWithNoAnnotation() throws Exception { assertThat(interceptor.hasRequiredAuthority(getTestMethod(), new DbUser())).isTrue(); }
@Test public void authorityCheckDeniesWhenUserMissingAuthority() throws Exception { Method apiControllerMethod = FakeController.class.getMethod("handle"); when(userDao.findUserWithAuthorities(USER_ID)).thenReturn(user); assertThat(interceptor.hasRequiredAuthority(apiControllerMethod, user)).isFalse(); }
@Test public void authorityCheckPermitsWhenUserHasAuthority() throws Exception { DbUser userWithAuthorities = new DbUser(); Set<Authority> required = new HashSet<>(); required.add(Authority.REVIEW_RESEARCH_PURPOSE); userWithAuthorities.setAuthoritiesEnum(required); when(userDao.findUserWithAuthorities(USER_ID)).thenReturn(userWithAuthorities); Method apiControllerMethod = FakeApiController.class.getMethod("handle"); assertThat(interceptor.hasRequiredAuthority(apiControllerMethod, user)).isTrue(); } |
### Question:
RequestTimeMetricInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle( HttpServletRequest request, HttpServletResponse response, Object handler) { if (shouldSkip(request, handler)) { return true; } request.setAttribute(RequestAttribute.START_INSTANT.toString(), clock.instant()); return true; } RequestTimeMetricInterceptor(LogsBasedMetricService logsBasedMetricService, Clock clock); @Override boolean preHandle(
HttpServletRequest request, HttpServletResponse response, Object handler); @Override void postHandle(
HttpServletRequest request,
HttpServletResponse response,
Object handler,
ModelAndView modelAndView); }### Answer:
@Test public void testPreHandle_getRequest() { boolean result = requestTimeMetricInterceptor.preHandle( mockHttpServletRequest, mockHttpServletResponse, mockHandlerMethod); assertThat(result).isTrue(); verify(mockHttpServletRequest) .setAttribute(attributeKeyCaptor.capture(), attributeValueCaptor.capture()); assertThat(attributeKeyCaptor.getValue()) .isEqualTo(RequestAttribute.START_INSTANT.getKeyName()); Object attrValueObj = attributeValueCaptor.getValue(); assertThat(attrValueObj instanceof Instant).isTrue(); assertThat((Instant) attrValueObj).isEqualTo(START_INSTANT); }
@Test public void testPreHandle_skipsOptionsRequest() { doReturn(HttpMethods.OPTIONS).when(mockHttpServletRequest).getMethod(); boolean result = requestTimeMetricInterceptor.preHandle( mockHttpServletRequest, mockHttpServletResponse, mockHandlerMethod); assertThat(result).isTrue(); verify(mockHttpServletRequest, never()).setAttribute(anyString(), any()); }
@Test public void testPreHandle_skipsUnsupportedHandler() { boolean result = requestTimeMetricInterceptor.preHandle( mockHttpServletRequest, mockHttpServletResponse, new Object()); assertThat(result).isTrue(); verify(mockHttpServletRequest, never()).setAttribute(anyString(), any()); } |
### Question:
QueryParameterValues { @NotNull public static String decorateParameterName(@NotNull String parameterName) { return "@" + parameterName; } @NotNull static String buildParameter(
@NotNull Map<String, QueryParameterValue> queryParameterValueMap,
@NotNull QueryParameterValue queryParameterValue); @NotNull static QueryParameterValue instantToQPValue(@Nullable Instant instant); static Optional<Instant> timestampStringToInstant(@Nullable String timestamp); static Optional<Instant> timestampQpvToInstant(@NotNull QueryParameterValue qpv); static void verifyQpvType(
@Nullable QueryParameterValue queryParameterValue, StandardSQLTypeName expectedType); static Optional<OffsetDateTime> timestampQpvToOffsetDateTime(
@Nullable QueryParameterValue queryParameterValue); @NotNull static String replaceNamedParameters(
@NotNull QueryJobConfiguration queryJobConfiguration); @NotNull static String formatQuery(@NotNull String query); @NotNull static String decorateParameterName(@NotNull String parameterName); @Nullable static QueryParameterValue toTimestampQpv(@Nullable OffsetDateTime offsetDateTime); @Nullable static String toInsertRowString(@Nullable OffsetDateTime offsetDateTime); static Optional<OffsetDateTime> rowToInsertStringToOffsetTimestamp(
@Nullable String bqTimeString); @NotNull static QueryParameterValue enumToQpv(@Nullable T enumValue); @Nullable static String enumToString(@Nullable T enumValue); static final DateTimeFormatter QPV_TIMESTAMP_FORMATTER; static final DateTimeFormatter ROW_TO_INSERT_TIMESTAMP_FORMATTER; }### Answer:
@Test public void testDecorateParameterName() { assertThat(decorateParameterName("foo")).isEqualTo("@foo"); } |
### Question:
QueryParameterValues { @NotNull public static QueryParameterValue instantToQPValue(@Nullable Instant instant) { final Long epochMicros = Optional.ofNullable(instant) .map(Instant::toEpochMilli) .map(milli -> milli * MICROSECONDS_IN_MILLISECOND) .orElse(null); return QueryParameterValue.timestamp(epochMicros); } @NotNull static String buildParameter(
@NotNull Map<String, QueryParameterValue> queryParameterValueMap,
@NotNull QueryParameterValue queryParameterValue); @NotNull static QueryParameterValue instantToQPValue(@Nullable Instant instant); static Optional<Instant> timestampStringToInstant(@Nullable String timestamp); static Optional<Instant> timestampQpvToInstant(@NotNull QueryParameterValue qpv); static void verifyQpvType(
@Nullable QueryParameterValue queryParameterValue, StandardSQLTypeName expectedType); static Optional<OffsetDateTime> timestampQpvToOffsetDateTime(
@Nullable QueryParameterValue queryParameterValue); @NotNull static String replaceNamedParameters(
@NotNull QueryJobConfiguration queryJobConfiguration); @NotNull static String formatQuery(@NotNull String query); @NotNull static String decorateParameterName(@NotNull String parameterName); @Nullable static QueryParameterValue toTimestampQpv(@Nullable OffsetDateTime offsetDateTime); @Nullable static String toInsertRowString(@Nullable OffsetDateTime offsetDateTime); static Optional<OffsetDateTime> rowToInsertStringToOffsetTimestamp(
@Nullable String bqTimeString); @NotNull static QueryParameterValue enumToQpv(@Nullable T enumValue); @Nullable static String enumToString(@Nullable T enumValue); static final DateTimeFormatter QPV_TIMESTAMP_FORMATTER; static final DateTimeFormatter ROW_TO_INSERT_TIMESTAMP_FORMATTER; }### Answer:
@Test public void testInstantToQpvValue_nullInput() { final QueryParameterValue qpv = instantToQPValue(null); assertThat(qpv.getType()).isEqualTo(StandardSQLTypeName.TIMESTAMP); assertThat(qpv.getValue()).isNull(); } |
### Question:
QueryParameterValues { @Nullable public static QueryParameterValue toTimestampQpv(@Nullable OffsetDateTime offsetDateTime) { final String arg = Optional.ofNullable(offsetDateTime).map(QPV_TIMESTAMP_FORMATTER::format).orElse(null); return QueryParameterValue.timestamp(arg); } @NotNull static String buildParameter(
@NotNull Map<String, QueryParameterValue> queryParameterValueMap,
@NotNull QueryParameterValue queryParameterValue); @NotNull static QueryParameterValue instantToQPValue(@Nullable Instant instant); static Optional<Instant> timestampStringToInstant(@Nullable String timestamp); static Optional<Instant> timestampQpvToInstant(@NotNull QueryParameterValue qpv); static void verifyQpvType(
@Nullable QueryParameterValue queryParameterValue, StandardSQLTypeName expectedType); static Optional<OffsetDateTime> timestampQpvToOffsetDateTime(
@Nullable QueryParameterValue queryParameterValue); @NotNull static String replaceNamedParameters(
@NotNull QueryJobConfiguration queryJobConfiguration); @NotNull static String formatQuery(@NotNull String query); @NotNull static String decorateParameterName(@NotNull String parameterName); @Nullable static QueryParameterValue toTimestampQpv(@Nullable OffsetDateTime offsetDateTime); @Nullable static String toInsertRowString(@Nullable OffsetDateTime offsetDateTime); static Optional<OffsetDateTime> rowToInsertStringToOffsetTimestamp(
@Nullable String bqTimeString); @NotNull static QueryParameterValue enumToQpv(@Nullable T enumValue); @Nullable static String enumToString(@Nullable T enumValue); static final DateTimeFormatter QPV_TIMESTAMP_FORMATTER; static final DateTimeFormatter ROW_TO_INSERT_TIMESTAMP_FORMATTER; }### Answer:
@Test public void testToTimestampQpv() { final QueryParameterValue qpv = toTimestampQpv(OFFSET_DATE_TIME); assertThat(qpv).isNotNull(); assertThat(qpv.getType()).isEqualTo(StandardSQLTypeName.TIMESTAMP); final Optional<OffsetDateTime> roundTripOdt = timestampQpvToOffsetDateTime(qpv); assertThat(roundTripOdt).isPresent(); assertTimeApprox(roundTripOdt.get(), OFFSET_DATE_TIME); } |
### Question:
QueryParameterValues { public static Optional<Instant> timestampQpvToInstant(@NotNull QueryParameterValue qpv) { verifyQpvType(qpv, StandardSQLTypeName.TIMESTAMP); return Optional.ofNullable(qpv.getValue()) .map(s -> ZonedDateTime.parse(s, QPV_TIMESTAMP_FORMATTER)) .map(ZonedDateTime::toInstant); } @NotNull static String buildParameter(
@NotNull Map<String, QueryParameterValue> queryParameterValueMap,
@NotNull QueryParameterValue queryParameterValue); @NotNull static QueryParameterValue instantToQPValue(@Nullable Instant instant); static Optional<Instant> timestampStringToInstant(@Nullable String timestamp); static Optional<Instant> timestampQpvToInstant(@NotNull QueryParameterValue qpv); static void verifyQpvType(
@Nullable QueryParameterValue queryParameterValue, StandardSQLTypeName expectedType); static Optional<OffsetDateTime> timestampQpvToOffsetDateTime(
@Nullable QueryParameterValue queryParameterValue); @NotNull static String replaceNamedParameters(
@NotNull QueryJobConfiguration queryJobConfiguration); @NotNull static String formatQuery(@NotNull String query); @NotNull static String decorateParameterName(@NotNull String parameterName); @Nullable static QueryParameterValue toTimestampQpv(@Nullable OffsetDateTime offsetDateTime); @Nullable static String toInsertRowString(@Nullable OffsetDateTime offsetDateTime); static Optional<OffsetDateTime> rowToInsertStringToOffsetTimestamp(
@Nullable String bqTimeString); @NotNull static QueryParameterValue enumToQpv(@Nullable T enumValue); @Nullable static String enumToString(@Nullable T enumValue); static final DateTimeFormatter QPV_TIMESTAMP_FORMATTER; static final DateTimeFormatter ROW_TO_INSERT_TIMESTAMP_FORMATTER; }### Answer:
@Test public void testTimestampQpvToInstant_nullQpvValue() { assertThat(timestampQpvToInstant(QueryParameterValue.timestamp((String) null))).isEmpty(); }
@Test(expected = IllegalArgumentException.class) public void testTimestampQpvToInstant_wrongQpvType() { timestampQpvToInstant(QueryParameterValue.bool(false)); } |
### Question:
QueryParameterValues { public static Optional<OffsetDateTime> timestampQpvToOffsetDateTime( @Nullable QueryParameterValue queryParameterValue) { verifyQpvType(queryParameterValue, StandardSQLTypeName.TIMESTAMP); return Optional.ofNullable(queryParameterValue) .flatMap(QueryParameterValues::timestampQpvToInstant) .map(i -> OffsetDateTime.ofInstant(i, ZoneOffset.UTC)); } @NotNull static String buildParameter(
@NotNull Map<String, QueryParameterValue> queryParameterValueMap,
@NotNull QueryParameterValue queryParameterValue); @NotNull static QueryParameterValue instantToQPValue(@Nullable Instant instant); static Optional<Instant> timestampStringToInstant(@Nullable String timestamp); static Optional<Instant> timestampQpvToInstant(@NotNull QueryParameterValue qpv); static void verifyQpvType(
@Nullable QueryParameterValue queryParameterValue, StandardSQLTypeName expectedType); static Optional<OffsetDateTime> timestampQpvToOffsetDateTime(
@Nullable QueryParameterValue queryParameterValue); @NotNull static String replaceNamedParameters(
@NotNull QueryJobConfiguration queryJobConfiguration); @NotNull static String formatQuery(@NotNull String query); @NotNull static String decorateParameterName(@NotNull String parameterName); @Nullable static QueryParameterValue toTimestampQpv(@Nullable OffsetDateTime offsetDateTime); @Nullable static String toInsertRowString(@Nullable OffsetDateTime offsetDateTime); static Optional<OffsetDateTime> rowToInsertStringToOffsetTimestamp(
@Nullable String bqTimeString); @NotNull static QueryParameterValue enumToQpv(@Nullable T enumValue); @Nullable static String enumToString(@Nullable T enumValue); static final DateTimeFormatter QPV_TIMESTAMP_FORMATTER; static final DateTimeFormatter ROW_TO_INSERT_TIMESTAMP_FORMATTER; }### Answer:
@Test public void testTimestampQpvToOffsetDateTime() { final Optional<OffsetDateTime> offsetDateTime = timestampQpvToOffsetDateTime(TIMESTAMP_QPV); assertTimeApprox(offsetDateTime.get().toInstant(), INSTANT); }
@Test public void testTimestampQpvToOffset_nullInput() { assertThat(timestampQpvToOffsetDateTime(null)).isEmpty(); } |
### Question:
QueryParameterValues { public static Optional<Instant> timestampStringToInstant(@Nullable String timestamp) { return Optional.ofNullable(timestamp) .map(s -> ZonedDateTime.parse(s, ROW_TO_INSERT_TIMESTAMP_FORMATTER)) .map(ZonedDateTime::toInstant); } @NotNull static String buildParameter(
@NotNull Map<String, QueryParameterValue> queryParameterValueMap,
@NotNull QueryParameterValue queryParameterValue); @NotNull static QueryParameterValue instantToQPValue(@Nullable Instant instant); static Optional<Instant> timestampStringToInstant(@Nullable String timestamp); static Optional<Instant> timestampQpvToInstant(@NotNull QueryParameterValue qpv); static void verifyQpvType(
@Nullable QueryParameterValue queryParameterValue, StandardSQLTypeName expectedType); static Optional<OffsetDateTime> timestampQpvToOffsetDateTime(
@Nullable QueryParameterValue queryParameterValue); @NotNull static String replaceNamedParameters(
@NotNull QueryJobConfiguration queryJobConfiguration); @NotNull static String formatQuery(@NotNull String query); @NotNull static String decorateParameterName(@NotNull String parameterName); @Nullable static QueryParameterValue toTimestampQpv(@Nullable OffsetDateTime offsetDateTime); @Nullable static String toInsertRowString(@Nullable OffsetDateTime offsetDateTime); static Optional<OffsetDateTime> rowToInsertStringToOffsetTimestamp(
@Nullable String bqTimeString); @NotNull static QueryParameterValue enumToQpv(@Nullable T enumValue); @Nullable static String enumToString(@Nullable T enumValue); static final DateTimeFormatter QPV_TIMESTAMP_FORMATTER; static final DateTimeFormatter ROW_TO_INSERT_TIMESTAMP_FORMATTER; }### Answer:
@Test public void testTimestampStringToInstant_nullInput() { assertThat(timestampStringToInstant(null)).isEmpty(); } |
### Question:
QueryParameterValues { @NotNull public static <T extends Enum<T>> QueryParameterValue enumToQpv(@Nullable T enumValue) { return QueryParameterValue.string(enumToString(enumValue)); } @NotNull static String buildParameter(
@NotNull Map<String, QueryParameterValue> queryParameterValueMap,
@NotNull QueryParameterValue queryParameterValue); @NotNull static QueryParameterValue instantToQPValue(@Nullable Instant instant); static Optional<Instant> timestampStringToInstant(@Nullable String timestamp); static Optional<Instant> timestampQpvToInstant(@NotNull QueryParameterValue qpv); static void verifyQpvType(
@Nullable QueryParameterValue queryParameterValue, StandardSQLTypeName expectedType); static Optional<OffsetDateTime> timestampQpvToOffsetDateTime(
@Nullable QueryParameterValue queryParameterValue); @NotNull static String replaceNamedParameters(
@NotNull QueryJobConfiguration queryJobConfiguration); @NotNull static String formatQuery(@NotNull String query); @NotNull static String decorateParameterName(@NotNull String parameterName); @Nullable static QueryParameterValue toTimestampQpv(@Nullable OffsetDateTime offsetDateTime); @Nullable static String toInsertRowString(@Nullable OffsetDateTime offsetDateTime); static Optional<OffsetDateTime> rowToInsertStringToOffsetTimestamp(
@Nullable String bqTimeString); @NotNull static QueryParameterValue enumToQpv(@Nullable T enumValue); @Nullable static String enumToString(@Nullable T enumValue); static final DateTimeFormatter QPV_TIMESTAMP_FORMATTER; static final DateTimeFormatter ROW_TO_INSERT_TIMESTAMP_FORMATTER; }### Answer:
@Test public void testEnumToQpv() { final QueryParameterValue qpv = enumToQpv(WorkspaceAccessLevel.READER); assertThat(qpv.getType()).isEqualTo(StandardSQLTypeName.STRING); assertThat(qpv.getValue()).isEqualTo("READER"); }
@Test public void testEnumToQpv_nullInput() { final QueryParameterValue qpv = enumToQpv(null); assertThat(qpv.getType()).isEqualTo(StandardSQLTypeName.STRING); assertThat(qpv.getValue()).isNull(); } |
### Question:
DelegatedUserCredentials extends OAuth2Credentials { @VisibleForTesting public JsonWebToken.Payload createJwtPayload() { JsonWebToken.Payload payload = new JsonWebToken.Payload(); payload.setIssuedAtTimeSeconds(Instant.now().getEpochSecond()); payload.setExpirationTimeSeconds( Instant.now().getEpochSecond() + ACCESS_TOKEN_DURATION.getSeconds()); payload.setAudience(GoogleOAuthConstants.TOKEN_SERVER_URL); payload.setIssuer(this.serviceAccountEmail); payload.setSubject(this.userEmail); payload.set("scope", String.join(" ", this.scopes)); return payload; } DelegatedUserCredentials(
String serviceAccountEmail,
String userEmail,
List<String> scopes,
IamCredentialsClient credentialsClient,
HttpTransport httpTransport); @VisibleForTesting void setClock(Clock clock); @VisibleForTesting JsonWebToken.Payload createJwtPayload(); @Override AccessToken refreshAccessToken(); static final Duration ACCESS_TOKEN_DURATION; }### Answer:
@Test public void testClaims() { JsonWebToken.Payload payload = delegatedCredentials.createJwtPayload(); assertThat(payload.getAudience()).isEqualTo(GoogleOAuthConstants.TOKEN_SERVER_URL); assertThat(payload.getIssuer()).isEqualTo(SERVICE_ACCOUNT_EMAIL); assertThat(payload.getSubject()).isEqualTo(USER_EMAIL); assertThat(payload.get("scope")).isEqualTo(String.join(" ", SCOPES)); } |
### Question:
CohortMaterializationService { public CohortAnnotationsResponse getAnnotations( DbCohortReview cohortReview, CohortAnnotationsRequest request) { List<CohortStatus> statusFilter = request.getStatusFilter(); if (statusFilter == null) { statusFilter = NOT_EXCLUDED; } AnnotationQueryBuilder.AnnotationResults results = annotationQueryBuilder.materializeAnnotationQuery( cohortReview, statusFilter, request.getAnnotationQuery(), null, 0L); return new CohortAnnotationsResponse() .results(ImmutableList.copyOf(results.getResults())) .columns(results.getColumns()); } @Autowired CohortMaterializationService(
FieldSetQueryBuilder fieldSetQueryBuilder,
AnnotationQueryBuilder annotationQueryBuilder,
ParticipantCohortStatusDao participantCohortStatusDao,
CdrBigQuerySchemaConfigService cdrBigQuerySchemaConfigService,
ConceptService conceptService,
Provider<WorkbenchConfig> configProvider); CdrQuery getCdrQuery(
String cohortSpec,
DataTableSpecification dataTableSpecification,
@Nullable DbCohortReview cohortReview,
@Nullable Set<Long> conceptIds); MaterializeCohortResponse materializeCohort(
@Nullable DbCohortReview cohortReview,
String cohortSpec,
@Nullable Set<Long> conceptIds,
MaterializeCohortRequest request); CohortAnnotationsResponse getAnnotations(
DbCohortReview cohortReview, CohortAnnotationsRequest request); }### Answer:
@Test public void testGetAnnotations() { CohortAnnotationsResponse response = cohortMaterializationService.getAnnotations( cohortReview, new CohortAnnotationsRequest().annotationQuery(new AnnotationQuery())); ImmutableMap<String, Object> p1Map = ImmutableMap.of("person_id", 1L, "review_status", "INCLUDED"); assertResults(response.getResults(), p1Map); } |
### Question:
RandomizeVcf extends VariantWalker { @VisibleForTesting protected VariantContext randomizeVariant(VariantContext variant) { VariantContextBuilder variantContextBuilder = new VariantContextBuilder(variant); variantContextBuilder.alleles(variant.getAlleles()); List<Genotype> randomizedGenotypes = this.sampleNames.stream() .map(name -> randomizeGenotype(variant, variant.getGenotype(0), name)) .collect(Collectors.toList()); GenotypesContext randomizedGenotypesContext = GenotypesContext.create(new ArrayList<>(randomizedGenotypes)); variantContextBuilder.genotypes(randomizedGenotypesContext); return variantContextBuilder.make(); } RandomizeVcf(); @VisibleForTesting protected RandomizeVcf(List<String> sampleNames, Random random); static void main(String[] argv); @Override void apply(
VariantContext variant,
ReadsContext readsContext,
ReferenceContext referenceContext,
FeatureContext featureContext); @Override void onTraversalStart(); @Override void closeTool(); }### Answer:
@Test public void testRandomizeVariant() { VariantContext randomizedVariant = randomizeVcf.randomizeVariant(variantContext); assertThat(randomizedVariant.getGenotypes().size()).isEqualTo(2); assertThat(randomizedVariant.getGenotypes().getSampleNames()) .isEqualTo(new HashSet<>(sampleNames)); randomizedVariant.getGenotypes().stream() .flatMap(genotype -> genotype.getAlleles().stream()) .forEach( allele -> assertThat( variantContext.getAlleles().stream() .anyMatch(vcAllele -> vcAllele.basesMatch(allele))) .isTrue()); } |
### Question:
ShibbolethServiceImpl implements ShibbolethService { @Override public void updateShibbolethToken(String jwt) { ShibbolethApi shibbolethApi = shibbolethApiProvider.get(); shibbolethRetryHandler.run( (context) -> { shibbolethApi.postShibbolethToken(jwt); return null; }); } @Autowired ShibbolethServiceImpl(
Provider<ShibbolethApi> shibbolethApiProvider,
ShibbolethRetryHandler shibbolethRetryHandler); @Override void updateShibbolethToken(String jwt); }### Answer:
@Test public void testUpdateShibbolethToken() throws Exception { shibbolethService.updateShibbolethToken("asdf"); verify(shibbolethApi, times(1)).postShibbolethToken("asdf"); } |
### Question:
ExceptionUtils { public static WorkbenchException convertNotebookException( org.pmiops.workbench.notebooks.ApiException e) { if (isSocketTimeoutException(e.getCause())) { throw new GatewayTimeoutException(); } throw codeToException(e.getCode()); } private ExceptionUtils(); static boolean isGoogleServiceUnavailableException(IOException e); static boolean isGoogleConflictException(IOException e); static WorkbenchException convertGoogleIOException(IOException e); static boolean isSocketTimeoutException(Throwable e); static WorkbenchException convertFirecloudException(ApiException e); static WorkbenchException convertNotebookException(
org.pmiops.workbench.notebooks.ApiException e); static WorkbenchException convertLeonardoException(
org.pmiops.workbench.leonardo.ApiException e); static WorkbenchException convertShibbolethException(
org.pmiops.workbench.shibboleth.ApiException e); static boolean isServiceUnavailable(int code); }### Answer:
@Test(expected = GatewayTimeoutException.class) public void convertNotebookException() throws Exception { ApiException cause = new ApiException(new SocketTimeoutException()); ExceptionUtils.convertNotebookException(cause); } |
### Question:
MeasurementBundle { public static Builder builder() { return new Builder(); } private MeasurementBundle(Map<Metric, Number> measurements, Map<MetricLabel, TagValue> tags); Map<Metric, Number> getMeasurements(); Map<TagKey, TagValue> getTags(); Optional<String> getTagValue(MetricLabel metricLabel); static Builder builder(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test(expected = IllegalStateException.class) public void testBuild_unsupportedAttachmentValueThrows() { MeasurementBundle.builder() .addTag(MetricLabel.BUFFER_ENTRY_STATUS, "lost and gone forever") .build(); } |
### Question:
MeasurementBundle { public Optional<String> getTagValue(MetricLabel metricLabel) { return Optional.ofNullable(tags.get(metricLabel)).map(TagValue::asString); } private MeasurementBundle(Map<Metric, Number> measurements, Map<MetricLabel, TagValue> tags); Map<Metric, Number> getMeasurements(); Map<TagKey, TagValue> getTags(); Optional<String> getTagValue(MetricLabel metricLabel); static Builder builder(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testGetTagValue() { final MeasurementBundle measurementBundle = MeasurementBundle.builder() .addMeasurement(GaugeMetric.BILLING_BUFFER_PROJECT_COUNT, 101L) .addTag(MetricLabel.BUFFER_ENTRY_STATUS, BufferEntryStatus.AVAILABLE.toString()) .build(); final Optional<String> labelValue = measurementBundle.getTagValue(MetricLabel.BUFFER_ENTRY_STATUS); assertThat(labelValue.isPresent()).isTrue(); assertThat(labelValue.orElse("wrong")).isEqualTo(BufferEntryStatus.AVAILABLE.toString()); final Optional<String> missingValue = measurementBundle.getTagValue(MetricLabel.METHOD_NAME); assertThat(missingValue.isPresent()).isFalse(); } |
### Question:
StackdriverStatsExporterService { @VisibleForTesting public StackdriverStatsConfiguration makeStackdriverStatsConfiguration() { return StackdriverStatsConfiguration.builder() .setMetricNamePrefix(STACKDRIVER_CUSTOM_METRICS_PREFIX) .setProjectId(getProjectId()) .setMonitoredResource(getMonitoringMonitoredResource()) .build(); } StackdriverStatsExporterService(
Provider<WorkbenchConfig> workbenchConfigProvider, ModulesService modulesService); void createAndRegister(); @VisibleForTesting StackdriverStatsConfiguration makeStackdriverStatsConfiguration(); com.google.cloud.MonitoredResource getLoggingMonitoredResource(); static final String PROJECT_ID_LABEL; static final String LOCATION_LABEL; static final String NAMESPACE_LABEL; static final String NODE_ID_LABEL; static final String UNKNOWN_INSTANCE_PREFIX; static final Set<String> MONITORED_RESOURCE_LABELS; }### Answer:
@Test public void testMakeMonitoredResource_noInstanceIdAvailable() { doThrow(ModulesException.class).when(mockModulesService).getCurrentInstanceId(); final MonitoredResource monitoredResource = exporterService.makeStackdriverStatsConfiguration().getMonitoredResource(); assertThat(monitoredResource.getLabelsMap().get("node_id")).isNotEmpty(); } |
### Question:
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); leonardoNotebooksClient.deleteRuntime(workspaceNamespace, userProvider.get().getRuntimeName()); return ResponseEntity.ok(new EmptyResponse()); } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }### Answer:
@Test public void testDeleteRuntime() throws ApiException { runtimeController.deleteRuntime(BILLING_PROJECT_ID); verify(userRuntimesApi).deleteRuntime(BILLING_PROJECT_ID, getRuntimeName(), false); } |
### Question:
S3Utilities { public URL getUrl(Consumer<GetUrlRequest.Builder> getUrlRequest) { return getUrl(GetUrlRequest.builder().applyMutation(getUrlRequest).build()); } private S3Utilities(Builder builder); static Builder builder(); URL getUrl(Consumer<GetUrlRequest.Builder> getUrlRequest); URL getUrl(GetUrlRequest getUrlRequest); }### Answer:
@Test public void test_utilities_createdThroughS3Client() throws MalformedURLException { assertThat(defaultUtilities.getUrl(requestWithoutSpaces()) .toExternalForm()) .isEqualTo("https: assertThat(defaultUtilities.getUrl(requestWithSpecialCharacters()) .toExternalForm()) .isEqualTo("https: }
@Test public void testAsync() throws MalformedURLException { assertThat(utilitiesFromAsyncClient.getUrl(requestWithoutSpaces()) .toExternalForm()) .isEqualTo("https: assertThat(utilitiesFromAsyncClient.getUrl(requestWithSpecialCharacters()) .toExternalForm()) .isEqualTo("https: } |
### Question:
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }### Answer:
@Test public void getObjectChecksumEnabledPerRequest_nonGetObjectRequestFalse() { assertThat(getObjectChecksumEnabledPerRequest(GetObjectAclRequest.builder().build(), new ExecutionAttributes())).isFalse(); }
@Test public void getObjectChecksumEnabledPerRequest_defaultReturnTrue() { assertThat(getObjectChecksumEnabledPerRequest(GetObjectRequest.builder().build(), new ExecutionAttributes())).isTrue(); }
@Test public void getObjectChecksumEnabledPerRequest_disabledPerConfig() { assertThat(getObjectChecksumEnabledPerRequest(GetObjectRequest.builder().build(), getExecutionAttributesWithChecksumDisabled())).isFalse(); } |
### Question:
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }### Answer:
@Test public void getObjectChecksumEnabledPerResponse_nonGetObjectRequestFalse() { assertThat(getObjectChecksumEnabledPerResponse(GetObjectAclRequest.builder().build(), getSdkHttpResponseWithChecksumHeader())).isFalse(); }
@Test public void getObjectChecksumEnabledPerResponse_responseContainsChecksumHeader_returnTrue() { assertThat(getObjectChecksumEnabledPerResponse(GetObjectRequest.builder().build(), getSdkHttpResponseWithChecksumHeader())).isTrue(); }
@Test public void getObjectChecksumEnabledPerResponse_responseNotContainsChecksumHeader_returnFalse() { assertThat(getObjectChecksumEnabledPerResponse(GetObjectRequest.builder().build(), SdkHttpFullResponse.builder().build())).isFalse(); } |
### Question:
ChecksumsEnabledValidator { public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }### Answer:
@Test public void responseChecksumIsValid_defaultTrue() { assertThat(responseChecksumIsValid(SdkHttpResponse.builder().build())).isTrue(); }
@Test public void responseChecksumIsValid_serverSideCustomerEncryption_false() { SdkHttpResponse response = SdkHttpResponse.builder() .putHeader(SERVER_SIDE_CUSTOMER_ENCRYPTION_HEADER, "test") .build(); assertThat(responseChecksumIsValid(response)).isFalse(); }
@Test public void responseChecksumIsValid_serverSideEncryption_false() { SdkHttpResponse response = SdkHttpResponse.builder() .putHeader(SERVER_SIDE_ENCRYPTION_HEADER, AWS_KMS.toString()) .build(); assertThat(responseChecksumIsValid(response)).isFalse(); } |
### Question:
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { return Optional.of(RequestBody.fromInputStream(new ByteArrayInputStream(new byte[0]), 0)); } return context.requestBody(); } @Override Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }### Answer:
@Test public void createMultipartRequest_shouldModifyHttpContent() { Context.ModifyHttpRequest modifyHttpRequest = InterceptorTestUtils.modifyHttpRequestContext(CreateMultipartUploadRequest.builder().build()); Optional<RequestBody> requestBody = interceptor.modifyHttpContent(modifyHttpRequest, new ExecutionAttributes()); assertThat(modifyHttpRequest.requestBody().get()).isNotEqualTo(requestBody.get()); }
@Test public void nonCreateMultipartRequest_shouldNotModifyHttpContent() { Context.ModifyHttpRequest modifyHttpRequest = InterceptorTestUtils.modifyHttpRequestContext(PutObjectRequest.builder().build()); Optional<RequestBody> requestBody = interceptor.modifyHttpContent(modifyHttpRequest, new ExecutionAttributes()); assertThat(modifyHttpRequest.requestBody().get()).isEqualTo(requestBody.get()); } |
### Question:
PayloadSigningInterceptor implements ExecutionInterceptor { public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { executionAttributes.putAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING, true); if (!context.requestBody().isPresent() && context.httpRequest().method().equals(SdkHttpMethod.POST)) { return Optional.of(RequestBody.fromBytes(new byte[0])); } return context.requestBody(); } Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }### Answer:
@Test public void modifyHttpContent_AddsExecutionAttributeAndPayload() { PayloadSigningInterceptor interceptor = new PayloadSigningInterceptor(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); Optional<RequestBody> modified = interceptor.modifyHttpContent(new Context(request, null), executionAttributes); assertThat(modified.isPresent()).isTrue(); assertThat(modified.get().contentLength()).isEqualTo(0); assertThat(executionAttributes.getAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING)).isTrue(); }
@Test public void modifyHttpContent_DoesNotReplaceBody() { PayloadSigningInterceptor interceptor = new PayloadSigningInterceptor(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); Optional<RequestBody> modified = interceptor.modifyHttpContent(new Context(request, RequestBody.fromString("hello")), executionAttributes); assertThat(modified.isPresent()).isTrue(); assertThat(modified.get().contentLength()).isEqualTo(5); assertThat(executionAttributes.getAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING)).isTrue(); } |
### Question:
AcceptJsonInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest httpRequest = context.httpRequest(); if (!httpRequest.headers().containsKey("Accept")) { return httpRequest .toBuilder() .putHeader("Accept", "application/json") .build(); } return httpRequest; } @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }### Answer:
@Test public void doesNotClobberExistingValue() { SdkHttpRequest request = newRequest("some-value"); Mockito.when(ctx.httpRequest()).thenReturn(request); request = interceptor.modifyHttpRequest(ctx, new ExecutionAttributes()); assertThat(request.headers().get("Accept")).containsOnly("some-value"); }
@Test public void addsStandardAcceptHeaderIfMissing() { SdkHttpRequest request = newRequest(null); Mockito.when(ctx.httpRequest()).thenReturn(request); request = interceptor.modifyHttpRequest(ctx, new ExecutionAttributes()); assertThat(request.headers().get("Accept")).containsOnly("application/json"); } |
### Question:
GetItemEnhancedRequest { public Builder toBuilder() { return builder().key(key).consistentRead(consistentRead); } private GetItemEnhancedRequest(Builder builder); static Builder builder(); Builder toBuilder(); Boolean consistentRead(); Key key(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void toBuilder() { Key key = Key.builder().partitionValue("key").build(); GetItemEnhancedRequest builtObject = GetItemEnhancedRequest.builder() .key(key) .build(); GetItemEnhancedRequest copiedObject = builtObject.toBuilder().build(); assertThat(copiedObject, is(builtObject)); } |
### Question:
BatchWriteItemEnhancedRequest { public Builder toBuilder() { return new Builder().writeBatches(writeBatches); } private BatchWriteItemEnhancedRequest(Builder builder); static Builder builder(); Builder toBuilder(); Collection<WriteBatch> writeBatches(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void toBuilder() { BatchWriteItemEnhancedRequest builtObject = BatchWriteItemEnhancedRequest.builder().build(); BatchWriteItemEnhancedRequest copiedObject = builtObject.toBuilder().build(); assertThat(copiedObject, is(builtObject)); } |
### Question:
PutItemEnhancedRequest { public Builder<T> toBuilder() { return new Builder<T>().item(item).conditionExpression(conditionExpression); } private PutItemEnhancedRequest(Builder<T> builder); static Builder<T> builder(Class<? extends T> itemClass); Builder<T> toBuilder(); T item(); Expression conditionExpression(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void toBuilder() { PutItemEnhancedRequest<FakeItem> builtObject = PutItemEnhancedRequest.builder(FakeItem.class).build(); PutItemEnhancedRequest copiedObject = builtObject.toBuilder().build(); assertThat(copiedObject, is(builtObject)); } |
### Question:
ScanEnhancedRequest { public static Builder builder() { return new Builder(); } private ScanEnhancedRequest(Builder builder); static Builder builder(); Builder toBuilder(); Map<String, AttributeValue> exclusiveStartKey(); Integer limit(); Boolean consistentRead(); Expression filterExpression(); List<String> attributesToProject(); List<NestedAttributeName> nestedAttributesToProject(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void test_nestedAttributesNullNestedAttributeElement() { List<NestedAttributeName> attributeNames = new ArrayList<>(); attributeNames.add(NestedAttributeName.create("foo")); attributeNames.add(null); assertFails(() -> ScanEnhancedRequest.builder() .addNestedAttributesToProject(attributeNames) .build()); assertFails(() -> ScanEnhancedRequest.builder() .addNestedAttributesToProject(NestedAttributeName.create("foo", "bar"), null) .build()); NestedAttributeName nestedAttributeName = null; ScanEnhancedRequest.builder() .addNestedAttributeToProject(nestedAttributeName) .build(); assertFails(() -> ScanEnhancedRequest.builder() .addNestedAttributesToProject(nestedAttributeName) .build()); } |
### Question:
ScanEnhancedRequest { public Builder toBuilder() { return builder().exclusiveStartKey(exclusiveStartKey) .limit(limit) .consistentRead(consistentRead) .filterExpression(filterExpression) .addNestedAttributesToProject(attributesToProject); } private ScanEnhancedRequest(Builder builder); static Builder builder(); Builder toBuilder(); Map<String, AttributeValue> exclusiveStartKey(); Integer limit(); Boolean consistentRead(); Expression filterExpression(); List<String> attributesToProject(); List<NestedAttributeName> nestedAttributesToProject(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void toBuilder() { ScanEnhancedRequest builtObject = ScanEnhancedRequest.builder().exclusiveStartKey(null).build(); ScanEnhancedRequest copiedObject = builtObject.toBuilder().build(); assertThat(copiedObject, is(builtObject)); } |
### Question:
CreateTableEnhancedRequest { public Builder toBuilder() { return builder().provisionedThroughput(provisionedThroughput) .localSecondaryIndices(localSecondaryIndices) .globalSecondaryIndices(globalSecondaryIndices); } private CreateTableEnhancedRequest(Builder builder); static Builder builder(); Builder toBuilder(); ProvisionedThroughput provisionedThroughput(); Collection<EnhancedLocalSecondaryIndex> localSecondaryIndices(); Collection<EnhancedGlobalSecondaryIndex> globalSecondaryIndices(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void toBuilder() { CreateTableEnhancedRequest builtObject = CreateTableEnhancedRequest.builder() .provisionedThroughput(getDefaultProvisionedThroughput()) .build(); CreateTableEnhancedRequest copiedObject = builtObject.toBuilder().build(); assertThat(copiedObject, is(builtObject)); } |
### Question:
DeleteItemEnhancedRequest { public Builder toBuilder() { return builder().key(key).conditionExpression(conditionExpression); } private DeleteItemEnhancedRequest(Builder builder); static Builder builder(); Builder toBuilder(); Key key(); Expression conditionExpression(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void toBuilder() { Key key = Key.builder().partitionValue("key").build(); DeleteItemEnhancedRequest builtObject = DeleteItemEnhancedRequest.builder().key(key).build(); DeleteItemEnhancedRequest copiedObject = builtObject.toBuilder().build(); assertThat(copiedObject, is(builtObject)); } |
### Question:
QueryEnhancedRequest { public static Builder builder() { return new Builder(); } private QueryEnhancedRequest(Builder builder); static Builder builder(); Builder toBuilder(); QueryConditional queryConditional(); Map<String, AttributeValue> exclusiveStartKey(); Boolean scanIndexForward(); Integer limit(); Boolean consistentRead(); Expression filterExpression(); List<String> attributesToProject(); List<NestedAttributeName> nestedAttributesToProject(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void test_nestedAttributesNullNestedAttributeElement() { List<NestedAttributeName> attributeNames = new ArrayList<>(); attributeNames.add(NestedAttributeName.create("foo")); attributeNames.add(null); assertFails(() -> QueryEnhancedRequest.builder() .addNestedAttributesToProject(attributeNames) .build()); assertFails(() -> QueryEnhancedRequest.builder() .addNestedAttributesToProject(NestedAttributeName.create("foo", "bar"), null) .build()); NestedAttributeName nestedAttributeName = null; QueryEnhancedRequest.builder() .addNestedAttributeToProject(nestedAttributeName) .build(); assertFails(() -> QueryEnhancedRequest.builder() .addNestedAttributesToProject(nestedAttributeName) .build()); } |
### Question:
QueryEnhancedRequest { public Builder toBuilder() { return builder().queryConditional(queryConditional) .exclusiveStartKey(exclusiveStartKey) .scanIndexForward(scanIndexForward) .limit(limit) .consistentRead(consistentRead) .filterExpression(filterExpression) .addNestedAttributesToProject(attributesToProject); } private QueryEnhancedRequest(Builder builder); static Builder builder(); Builder toBuilder(); QueryConditional queryConditional(); Map<String, AttributeValue> exclusiveStartKey(); Boolean scanIndexForward(); Integer limit(); Boolean consistentRead(); Expression filterExpression(); List<String> attributesToProject(); List<NestedAttributeName> nestedAttributesToProject(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void toBuilder() { QueryEnhancedRequest builtObject = QueryEnhancedRequest.builder().build(); QueryEnhancedRequest copiedObject = builtObject.toBuilder().build(); assertThat(copiedObject, is(builtObject)); } |
### Question:
UpdateItemEnhancedRequest { public Builder<T> toBuilder() { return new Builder<T>().item(item).ignoreNulls(ignoreNulls); } private UpdateItemEnhancedRequest(Builder<T> builder); static Builder<T> builder(Class<? extends T> itemClass); Builder<T> toBuilder(); T item(); Boolean ignoreNulls(); Expression conditionExpression(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void toBuilder() { UpdateItemEnhancedRequest<FakeItem> builtObject = UpdateItemEnhancedRequest.builder(FakeItem.class).build(); UpdateItemEnhancedRequest copiedObject = builtObject.toBuilder().build(); assertThat(copiedObject, is(builtObject)); } |
### Question:
BatchGetItemEnhancedRequest { public Builder toBuilder() { return new Builder().readBatches(readBatches); } private BatchGetItemEnhancedRequest(Builder builder); static Builder builder(); Builder toBuilder(); Collection<ReadBatch> readBatches(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void toBuilder() { BatchGetItemEnhancedRequest builtObject = BatchGetItemEnhancedRequest.builder().build(); BatchGetItemEnhancedRequest copiedObject = builtObject.toBuilder().build(); assertThat(copiedObject, is(builtObject)); } |
### Question:
ImmutableAttribute { public Builder<T, B, R> toBuilder() { return new Builder<T, B, R>(this.type).name(this.name) .getter(this.getter) .setter(this.setter) .tags(this.tags) .attributeConverter(this.attributeConverter); } private ImmutableAttribute(Builder<T, B, R> builder); static Builder<T, B, R> builder(Class<T> itemClass,
Class<B> builderClass,
EnhancedType<R> attributeType); static Builder<T, B, R> builder(Class<T> itemClass,
Class<B> builderClass,
Class<R> attributeClass); String name(); Function<T, R> getter(); BiConsumer<B, R> setter(); Collection<StaticAttributeTag> tags(); EnhancedType<R> type(); AttributeConverter<R> attributeConverter(); Builder<T, B, R> toBuilder(); }### Answer:
@Test public void toBuilder() { ImmutableAttribute<Object, Object, String> immutableAttribute = ImmutableAttribute.builder(Object.class, Object.class, String.class) .name("test-attribute") .getter(TEST_GETTER) .setter(TEST_SETTER) .tags(mockTag, mockTag2) .attributeConverter(attributeConverter) .build(); ImmutableAttribute<Object, Object, String> clonedAttribute = immutableAttribute.toBuilder().build(); assertThat(clonedAttribute.name()).isEqualTo("test-attribute"); assertThat(clonedAttribute.getter()).isSameAs(TEST_GETTER); assertThat(clonedAttribute.setter()).isSameAs(TEST_SETTER); assertThat(clonedAttribute.tags()).containsExactly(mockTag, mockTag2); assertThat(clonedAttribute.type()).isEqualTo(EnhancedType.of(String.class)); assertThat(clonedAttribute.attributeConverter()).isSameAs(attributeConverter); } |
### Question:
StaticImmutableTableSchema implements TableSchema<T> { @Override public EnhancedType<T> itemType() { return this.itemType; } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }### Answer:
@Test public void itemType_returnsCorrectClass() { assertThat(FakeItem.getTableSchema().itemType(), is(equalTo(EnhancedType.of(FakeItem.class)))); } |
### Question:
StaticImmutableTableSchema implements TableSchema<T> { @Override public StaticTableMetadata tableMetadata() { return tableMetadata; } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }### Answer:
@Test public void getTableMetadata_hasCorrectFields() { TableMetadata tableMetadata = FakeItemWithSort.getTableSchema().tableMetadata(); assertThat(tableMetadata.primaryPartitionKey(), is("id")); assertThat(tableMetadata.primarySortKey(), is(Optional.of("sort"))); } |
### Question:
S3Utilities { public static Builder builder() { return new Builder(); } private S3Utilities(Builder builder); static Builder builder(); URL getUrl(Consumer<GetUrlRequest.Builder> getUrlRequest); URL getUrl(GetUrlRequest getUrlRequest); }### Answer:
@Test (expected = NullPointerException.class) public void failIfRegionIsNotSetOnS3UtilitiesObject() throws MalformedURLException { S3Utilities.builder().build(); } |
### Question:
StaticAttribute { public Builder<T, R> toBuilder() { return new Builder<>(this.delegateAttribute.toBuilder()); } private StaticAttribute(Builder<T, R> builder); static Builder<T, R> builder(Class<T> itemClass, EnhancedType<R> attributeType); static Builder<T, R> builder(Class<T> itemClass, Class<R> attributeClass); String name(); Function<T, R> getter(); BiConsumer<T, R> setter(); Collection<StaticAttributeTag> tags(); EnhancedType<R> type(); AttributeConverter<R> attributeConverter(); Builder<T, R> toBuilder(); }### Answer:
@Test public void toBuilder() { StaticAttribute<Object, String> staticAttribute = StaticAttribute.builder(Object.class, String.class) .name("test-attribute") .getter(TEST_GETTER) .setter(TEST_SETTER) .tags(mockTag, mockTag2) .attributeConverter(attributeConverter) .build(); StaticAttribute<Object, String> clonedAttribute = staticAttribute.toBuilder().build(); assertThat(clonedAttribute.name()).isEqualTo("test-attribute"); assertThat(clonedAttribute.getter()).isSameAs(TEST_GETTER); assertThat(clonedAttribute.setter()).isSameAs(TEST_SETTER); assertThat(clonedAttribute.tags()).containsExactly(mockTag, mockTag2); assertThat(clonedAttribute.type()).isEqualTo(EnhancedType.of(String.class)); assertThat(clonedAttribute.attributeConverter()).isSameAs(attributeConverter); } |
### Question:
EnableTrailingChecksumInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (getObjectChecksumEnabledPerRequest(context.request(), executionAttributes)) { return context.httpRequest().toBuilder().putHeader(ENABLE_CHECKSUM_REQUEST_HEADER, ENABLE_MD5_CHECKSUM_HEADER_VALUE) .build(); } return context.httpRequest(); } @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }### Answer:
@Test public void modifyHttpRequest_getObjectTrailingChecksumEnabled_shouldAddTrailingChecksumHeader() { Context.ModifyHttpRequest modifyHttpRequestContext = modifyHttpRequestContext(GetObjectRequest.builder().build()); SdkHttpRequest sdkHttpRequest = interceptor.modifyHttpRequest(modifyHttpRequestContext, new ExecutionAttributes()); assertThat(sdkHttpRequest.headers().get(ENABLE_CHECKSUM_REQUEST_HEADER)).containsOnly(ENABLE_MD5_CHECKSUM_HEADER_VALUE); }
@Test public void modifyHttpRequest_getObjectTrailingChecksumDisabled_shouldNotModifyHttpRequest() { Context.ModifyHttpRequest modifyHttpRequestContext = modifyHttpRequestContext(GetObjectRequest.builder().build()); SdkHttpRequest sdkHttpRequest = interceptor.modifyHttpRequest(modifyHttpRequestContext, new ExecutionAttributes().putAttribute(AwsSignerExecutionAttribute.SERVICE_CONFIG, S3Configuration.builder().checksumValidationEnabled(false).build())); assertThat(sdkHttpRequest).isEqualToComparingFieldByField(modifyHttpRequestContext.httpRequest()); }
@Test public void modifyHttpRequest_nonGetObjectRequest_shouldNotModifyHttpRequest() { Context.ModifyHttpRequest modifyHttpRequestContext = modifyHttpRequestContext(PutObjectRequest.builder().build()); SdkHttpRequest sdkHttpRequest = interceptor.modifyHttpRequest(modifyHttpRequestContext, new ExecutionAttributes()); assertThat(sdkHttpRequest).isEqualToComparingFieldByField(modifyHttpRequestContext.httpRequest()); } |
### Question:
Key { public Optional<AttributeValue> sortKeyValue() { return Optional.ofNullable(sortValue); } private Key(Builder builder); static Builder builder(); Map<String, AttributeValue> keyMap(TableSchema<?> tableSchema, String index); AttributeValue partitionKeyValue(); Optional<AttributeValue> sortKeyValue(); Map<String, AttributeValue> primaryKeyMap(TableSchema<?> tableSchema); Builder toBuilder(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void getSortKeyValue_partitionOnly() { assertThat(partitionOnlyKey.sortKeyValue(), is(Optional.empty())); } |
### Question:
Key { public Builder toBuilder() { return new Builder().partitionValue(this.partitionValue).sortValue(this.sortValue); } private Key(Builder builder); static Builder builder(); Map<String, AttributeValue> keyMap(TableSchema<?> tableSchema, String index); AttributeValue partitionKeyValue(); Optional<AttributeValue> sortKeyValue(); Map<String, AttributeValue> primaryKeyMap(TableSchema<?> tableSchema); Builder toBuilder(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void toBuilder() { Key keyClone = key.toBuilder().build(); assertThat(key, is(equalTo(keyClone))); } |
### Question:
Key { public static Builder builder() { return new Builder(); } private Key(Builder builder); static Builder builder(); Map<String, AttributeValue> keyMap(TableSchema<?> tableSchema, String index); AttributeValue partitionKeyValue(); Optional<AttributeValue> sortKeyValue(); Map<String, AttributeValue> primaryKeyMap(TableSchema<?> tableSchema); Builder toBuilder(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void nullPartitionKey_shouldThrowException() { AttributeValue attributeValue = null; assertThatThrownBy(() -> Key.builder().partitionValue(attributeValue).build()) .isInstanceOf(IllegalArgumentException.class).hasMessageContaining("partitionValue should not be null"); assertThatThrownBy(() -> Key.builder().partitionValue(AttributeValue.builder().nul(true).build()).build()) .isInstanceOf(IllegalArgumentException.class).hasMessageContaining("partitionValue should not be null"); } |
### Question:
ApplyUserAgentInterceptor implements ExecutionInterceptor { @Override public SdkRequest modifyRequest(Context.ModifyRequest context, ExecutionAttributes executionAttributes) { if (!(context.request() instanceof DynamoDbRequest)) { return context.request(); } DynamoDbRequest request = (DynamoDbRequest) context.request(); AwsRequestOverrideConfiguration overrideConfiguration = request.overrideConfiguration().map(c -> c.toBuilder() .applyMutation(USER_AGENT_APPLIER) .build()) .orElse((AwsRequestOverrideConfiguration.builder() .applyMutation(USER_AGENT_APPLIER) .build())); return request.toBuilder().overrideConfiguration(overrideConfiguration).build(); } @Override SdkRequest modifyRequest(Context.ModifyRequest context, ExecutionAttributes executionAttributes); }### Answer:
@Test public void ddbRequest_shouldModifyRequest() { GetItemRequest getItemRequest = GetItemRequest.builder().build(); SdkRequest sdkRequest = interceptor.modifyRequest(() -> getItemRequest, new ExecutionAttributes()); RequestOverrideConfiguration requestOverrideConfiguration = sdkRequest.overrideConfiguration().get(); assertThat(requestOverrideConfiguration.apiNames() .stream() .filter(a -> a.name() .equals("hll") && a.version().equals("ddb-enh")).findAny()) .isPresent(); }
@Test public void otherRequest_shouldNotModifyRequest() { SdkRequest someOtherRequest = new SdkRequest() { @Override public List<SdkField<?>> sdkFields() { return null; } @Override public Optional<? extends RequestOverrideConfiguration> overrideConfiguration() { return Optional.empty(); } @Override public Builder toBuilder() { return null; } }; SdkRequest sdkRequest = interceptor.modifyRequest(() -> someOtherRequest, new ExecutionAttributes()); assertThat(sdkRequest).isEqualTo(someOtherRequest); } |
### Question:
ScanOperation implements PaginatedTableOperation<T, ScanRequest, ScanResponse>,
PaginatedIndexOperation<T, ScanRequest, ScanResponse> { @Override public Function<ScanRequest, SdkIterable<ScanResponse>> serviceCall(DynamoDbClient dynamoDbClient) { return dynamoDbClient::scanPaginator; } private ScanOperation(ScanEnhancedRequest request); static ScanOperation<T> create(ScanEnhancedRequest request); @Override ScanRequest generateRequest(TableSchema<T> tableSchema,
OperationContext operationContext,
DynamoDbEnhancedClientExtension extension); @Override Page<T> transformResponse(ScanResponse response,
TableSchema<T> tableSchema,
OperationContext context,
DynamoDbEnhancedClientExtension dynamoDbEnhancedClientExtension); @Override Function<ScanRequest, SdkIterable<ScanResponse>> serviceCall(DynamoDbClient dynamoDbClient); @Override Function<ScanRequest, SdkPublisher<ScanResponse>> asyncServiceCall(DynamoDbAsyncClient dynamoDbAsyncClient); }### Answer:
@Test public void getServiceCall_makesTheRightCallAndReturnsResponse() { ScanRequest scanRequest = ScanRequest.builder().build(); ScanIterable mockScanIterable = mock(ScanIterable.class); when(mockDynamoDbClient.scanPaginator(any(ScanRequest.class))).thenReturn(mockScanIterable); SdkIterable<ScanResponse> response = scanOperation.serviceCall(mockDynamoDbClient).apply(scanRequest); assertThat(response, is(mockScanIterable)); verify(mockDynamoDbClient).scanPaginator(scanRequest); } |
### Question:
ScanOperation implements PaginatedTableOperation<T, ScanRequest, ScanResponse>,
PaginatedIndexOperation<T, ScanRequest, ScanResponse> { @Override public Function<ScanRequest, SdkPublisher<ScanResponse>> asyncServiceCall(DynamoDbAsyncClient dynamoDbAsyncClient) { return dynamoDbAsyncClient::scanPaginator; } private ScanOperation(ScanEnhancedRequest request); static ScanOperation<T> create(ScanEnhancedRequest request); @Override ScanRequest generateRequest(TableSchema<T> tableSchema,
OperationContext operationContext,
DynamoDbEnhancedClientExtension extension); @Override Page<T> transformResponse(ScanResponse response,
TableSchema<T> tableSchema,
OperationContext context,
DynamoDbEnhancedClientExtension dynamoDbEnhancedClientExtension); @Override Function<ScanRequest, SdkIterable<ScanResponse>> serviceCall(DynamoDbClient dynamoDbClient); @Override Function<ScanRequest, SdkPublisher<ScanResponse>> asyncServiceCall(DynamoDbAsyncClient dynamoDbAsyncClient); }### Answer:
@Test public void getAsyncServiceCall_makesTheRightCallAndReturnsResponse() { ScanRequest scanRequest = ScanRequest.builder().build(); ScanPublisher mockScanPublisher = mock(ScanPublisher.class); when(mockDynamoDbAsyncClient.scanPaginator(any(ScanRequest.class))).thenReturn(mockScanPublisher); SdkPublisher<ScanResponse> response = scanOperation.asyncServiceCall(mockDynamoDbAsyncClient) .apply(scanRequest); assertThat(response, is(mockScanPublisher)); verify(mockDynamoDbAsyncClient).scanPaginator(scanRequest); } |
### Question:
QueryOperation implements PaginatedTableOperation<T, QueryRequest, QueryResponse>,
PaginatedIndexOperation<T, QueryRequest, QueryResponse> { @Override public Function<QueryRequest, SdkIterable<QueryResponse>> serviceCall(DynamoDbClient dynamoDbClient) { return dynamoDbClient::queryPaginator; } private QueryOperation(QueryEnhancedRequest request); static QueryOperation<T> create(QueryEnhancedRequest request); @Override QueryRequest generateRequest(TableSchema<T> tableSchema,
OperationContext operationContext,
DynamoDbEnhancedClientExtension extension); @Override Function<QueryRequest, SdkIterable<QueryResponse>> serviceCall(DynamoDbClient dynamoDbClient); @Override Function<QueryRequest, SdkPublisher<QueryResponse>> asyncServiceCall(DynamoDbAsyncClient dynamoDbAsyncClient); @Override Page<T> transformResponse(QueryResponse response,
TableSchema<T> tableSchema,
OperationContext context,
DynamoDbEnhancedClientExtension dynamoDbEnhancedClientExtension); }### Answer:
@Test public void getServiceCall_makesTheRightCallAndReturnsResponse() { QueryRequest queryRequest = QueryRequest.builder().build(); QueryIterable mockQueryIterable = mock(QueryIterable.class); when(mockDynamoDbClient.queryPaginator(any(QueryRequest.class))).thenReturn(mockQueryIterable); SdkIterable<QueryResponse> response = queryOperation.serviceCall(mockDynamoDbClient).apply(queryRequest); assertThat(response, is(mockQueryIterable)); verify(mockDynamoDbClient).queryPaginator(queryRequest); } |
### Question:
QueryOperation implements PaginatedTableOperation<T, QueryRequest, QueryResponse>,
PaginatedIndexOperation<T, QueryRequest, QueryResponse> { @Override public Function<QueryRequest, SdkPublisher<QueryResponse>> asyncServiceCall(DynamoDbAsyncClient dynamoDbAsyncClient) { return dynamoDbAsyncClient::queryPaginator; } private QueryOperation(QueryEnhancedRequest request); static QueryOperation<T> create(QueryEnhancedRequest request); @Override QueryRequest generateRequest(TableSchema<T> tableSchema,
OperationContext operationContext,
DynamoDbEnhancedClientExtension extension); @Override Function<QueryRequest, SdkIterable<QueryResponse>> serviceCall(DynamoDbClient dynamoDbClient); @Override Function<QueryRequest, SdkPublisher<QueryResponse>> asyncServiceCall(DynamoDbAsyncClient dynamoDbAsyncClient); @Override Page<T> transformResponse(QueryResponse response,
TableSchema<T> tableSchema,
OperationContext context,
DynamoDbEnhancedClientExtension dynamoDbEnhancedClientExtension); }### Answer:
@Test public void getAsyncServiceCall_makesTheRightCallAndReturnsResponse() { QueryRequest queryRequest = QueryRequest.builder().build(); QueryPublisher mockQueryPublisher = mock(QueryPublisher.class); when(mockDynamoDbAsyncClient.queryPaginator(any(QueryRequest.class))).thenReturn(mockQueryPublisher); SdkPublisher<QueryResponse> response = queryOperation.asyncServiceCall(mockDynamoDbAsyncClient).apply(queryRequest); assertThat(response, is(mockQueryPublisher)); verify(mockDynamoDbAsyncClient).queryPaginator(queryRequest); } |
### Question:
MetaTableSchemaCache { public <T> Optional<MetaTableSchema<T>> get(Class<T> mappedClass) { return Optional.ofNullable((MetaTableSchema<T>) cacheMap().get(mappedClass)); } MetaTableSchema<T> getOrCreate(Class<T> mappedClass); Optional<MetaTableSchema<T>> get(Class<T> mappedClass); }### Answer:
@Test public void getKeyNotInMap() { assertThat(metaTableSchemaCache.get(FakeItem.class)).isNotPresent(); } |
### Question:
MetaTableSchemaCache { public <T> MetaTableSchema<T> getOrCreate(Class<T> mappedClass) { return (MetaTableSchema<T>) cacheMap().computeIfAbsent( mappedClass, ignored -> MetaTableSchema.create(mappedClass)); } MetaTableSchema<T> getOrCreate(Class<T> mappedClass); Optional<MetaTableSchema<T>> get(Class<T> mappedClass); }### Answer:
@Test public void createReturnsExistingObject() { MetaTableSchema<FakeItem> metaTableSchema = metaTableSchemaCache.getOrCreate(FakeItem.class); assertThat(metaTableSchema).isNotNull(); assertThat(metaTableSchemaCache.getOrCreate(FakeItem.class)).isSameAs(metaTableSchema); } |
### Question:
DefaultDynamoDbEnhancedAsyncClient implements DynamoDbEnhancedAsyncClient { public Builder toBuilder() { return builder().dynamoDbClient(this.dynamoDbClient).extensions(this.extension); } private DefaultDynamoDbEnhancedAsyncClient(Builder builder); static Builder builder(); @Override DefaultDynamoDbAsyncTable<T> table(String tableName, TableSchema<T> tableSchema); @Override BatchGetResultPagePublisher batchGetItem(BatchGetItemEnhancedRequest request); @Override BatchGetResultPagePublisher batchGetItem(
Consumer<BatchGetItemEnhancedRequest.Builder> requestConsumer); @Override CompletableFuture<BatchWriteResult> batchWriteItem(BatchWriteItemEnhancedRequest request); @Override CompletableFuture<BatchWriteResult> batchWriteItem(
Consumer<BatchWriteItemEnhancedRequest.Builder> requestConsumer); @Override CompletableFuture<List<Document>> transactGetItems(TransactGetItemsEnhancedRequest request); @Override CompletableFuture<List<Document>> transactGetItems(
Consumer<TransactGetItemsEnhancedRequest.Builder> requestConsumer); @Override CompletableFuture<Void> transactWriteItems(TransactWriteItemsEnhancedRequest request); @Override CompletableFuture<Void> transactWriteItems(
Consumer<TransactWriteItemsEnhancedRequest.Builder> requestConsumer); DynamoDbAsyncClient dynamoDbAsyncClient(); DynamoDbEnhancedClientExtension mapperExtension(); Builder toBuilder(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void toBuilder() { DefaultDynamoDbEnhancedAsyncClient copiedObject = dynamoDbEnhancedAsyncClient.toBuilder().build(); assertThat(copiedObject, is(dynamoDbEnhancedAsyncClient)); } |
### Question:
ExtensionResolver { public static List<DynamoDbEnhancedClientExtension> defaultExtensions() { return DEFAULT_EXTENSIONS; } private ExtensionResolver(); static List<DynamoDbEnhancedClientExtension> defaultExtensions(); static DynamoDbEnhancedClientExtension resolveExtensions(List<DynamoDbEnhancedClientExtension> extensions); }### Answer:
@Test public void defaultExtensions_isImmutable() { List<DynamoDbEnhancedClientExtension> defaultExtensions = ExtensionResolver.defaultExtensions(); assertThatThrownBy(() -> defaultExtensions.add(mockExtension1)).isInstanceOf(UnsupportedOperationException.class); } |
### Question:
DefaultDynamoDbEnhancedClient implements DynamoDbEnhancedClient { @Override public <T> DefaultDynamoDbTable<T> table(String tableName, TableSchema<T> tableSchema) { return new DefaultDynamoDbTable<>(dynamoDbClient, extension, tableSchema, tableName); } private DefaultDynamoDbEnhancedClient(Builder builder); static Builder builder(); @Override DefaultDynamoDbTable<T> table(String tableName, TableSchema<T> tableSchema); @Override BatchGetResultPageIterable batchGetItem(BatchGetItemEnhancedRequest request); @Override BatchGetResultPageIterable batchGetItem(Consumer<BatchGetItemEnhancedRequest.Builder> requestConsumer); @Override BatchWriteResult batchWriteItem(BatchWriteItemEnhancedRequest request); @Override BatchWriteResult batchWriteItem(Consumer<BatchWriteItemEnhancedRequest.Builder> requestConsumer); @Override List<Document> transactGetItems(TransactGetItemsEnhancedRequest request); @Override List<Document> transactGetItems(
Consumer<TransactGetItemsEnhancedRequest.Builder> requestConsumer); @Override Void transactWriteItems(TransactWriteItemsEnhancedRequest request); @Override Void transactWriteItems(Consumer<TransactWriteItemsEnhancedRequest.Builder> requestConsumer); DynamoDbClient dynamoDbClient(); DynamoDbEnhancedClientExtension mapperExtension(); Builder toBuilder(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void table() { DefaultDynamoDbTable<Object> mappedTable = dynamoDbEnhancedClient.table("table-name", mockTableSchema); assertThat(mappedTable.dynamoDbClient(), is(mockDynamoDbClient)); assertThat(mappedTable.mapperExtension(), is(mockDynamoDbEnhancedClientExtension)); assertThat(mappedTable.tableSchema(), is(mockTableSchema)); assertThat(mappedTable.tableName(), is("table-name")); } |
### Question:
DefaultDynamoDbEnhancedClient implements DynamoDbEnhancedClient { public Builder toBuilder() { return builder().dynamoDbClient(this.dynamoDbClient).extensions(this.extension); } private DefaultDynamoDbEnhancedClient(Builder builder); static Builder builder(); @Override DefaultDynamoDbTable<T> table(String tableName, TableSchema<T> tableSchema); @Override BatchGetResultPageIterable batchGetItem(BatchGetItemEnhancedRequest request); @Override BatchGetResultPageIterable batchGetItem(Consumer<BatchGetItemEnhancedRequest.Builder> requestConsumer); @Override BatchWriteResult batchWriteItem(BatchWriteItemEnhancedRequest request); @Override BatchWriteResult batchWriteItem(Consumer<BatchWriteItemEnhancedRequest.Builder> requestConsumer); @Override List<Document> transactGetItems(TransactGetItemsEnhancedRequest request); @Override List<Document> transactGetItems(
Consumer<TransactGetItemsEnhancedRequest.Builder> requestConsumer); @Override Void transactWriteItems(TransactWriteItemsEnhancedRequest request); @Override Void transactWriteItems(Consumer<TransactWriteItemsEnhancedRequest.Builder> requestConsumer); DynamoDbClient dynamoDbClient(); DynamoDbEnhancedClientExtension mapperExtension(); Builder toBuilder(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void toBuilder() { DefaultDynamoDbEnhancedClient copiedObject = dynamoDbEnhancedClient.toBuilder().build(); assertThat(copiedObject, is(dynamoDbEnhancedClient)); } |
### Question:
GetObjectPresignRequest extends PresignRequest implements ToCopyableBuilder<GetObjectPresignRequest.Builder, GetObjectPresignRequest> { public static Builder builder() { return new DefaultBuilder(); } private GetObjectPresignRequest(DefaultBuilder builder); static Builder builder(); GetObjectRequest getObjectRequest(); @Override Builder toBuilder(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void build_missingProperty_getObjectRequest() { assertThatThrownBy(() -> GetObjectPresignRequest.builder() .signatureDuration(Duration.ofSeconds(123L)) .build()) .isInstanceOf(NullPointerException.class) .hasMessageContaining("getObjectRequest"); } |
### Question:
ConverterProviderResolver { public static AttributeConverterProvider resolveProviders(List<AttributeConverterProvider> providers) { if (providers == null || providers.isEmpty()) { return null; } if (providers.size() == 1) { return providers.get(0); } return ChainConverterProvider.create(providers); } private ConverterProviderResolver(); static AttributeConverterProvider defaultConverterProvider(); static AttributeConverterProvider resolveProviders(List<AttributeConverterProvider> providers); }### Answer:
@Test public void resolveProviders_null() { assertThat(ConverterProviderResolver.resolveProviders(null)).isNull(); }
@Test public void resolveProviders_empty() { assertThat(ConverterProviderResolver.resolveProviders(emptyList())).isNull(); }
@Test public void resolveProviders_singleton() { assertThat(ConverterProviderResolver.resolveProviders(singletonList(mockConverterProvider1))) .isSameAs(mockConverterProvider1); }
@Test public void resolveProviders_multiple() { AttributeConverterProvider result = ConverterProviderResolver.resolveProviders( Arrays.asList(mockConverterProvider1, mockConverterProvider2)); assertThat(result).isNotNull(); assertThat(result).isInstanceOf(ChainConverterProvider.class); } |
### Question:
ConverterProviderResolver { public static AttributeConverterProvider defaultConverterProvider() { return DEFAULT_ATTRIBUTE_CONVERTER; } private ConverterProviderResolver(); static AttributeConverterProvider defaultConverterProvider(); static AttributeConverterProvider resolveProviders(List<AttributeConverterProvider> providers); }### Answer:
@Test public void defaultProvider_returnsInstance() { AttributeConverterProvider defaultProvider = ConverterProviderResolver.defaultConverterProvider(); assertThat(defaultProvider).isNotNull(); assertThat(defaultProvider).isInstanceOf(DefaultAttributeConverterProvider.class); } |
### Question:
EnhancedClientUtils { public static String cleanAttributeName(String key) { boolean somethingChanged = false; char[] chars = key.toCharArray(); for (int i = 0; i < chars.length; ++i) { if (chars[i] == '*' || chars[i] == '.' || chars[i] == '-' || chars[i] == '#' || chars[i] == ':') { chars[i] = '_'; somethingChanged = true; } } return somethingChanged ? new String(chars) : key; } private EnhancedClientUtils(); static String cleanAttributeName(String key); static T readAndTransformSingleItem(Map<String, AttributeValue> itemMap,
TableSchema<T> tableSchema,
OperationContext operationContext,
DynamoDbEnhancedClientExtension dynamoDbEnhancedClientExtension); static Page<ItemT> readAndTransformPaginatedItems(
ResponseT response,
TableSchema<ItemT> tableSchema,
OperationContext operationContext,
DynamoDbEnhancedClientExtension dynamoDbEnhancedClientExtension,
Function<ResponseT, List<Map<String, AttributeValue>>> getItems,
Function<ResponseT, Map<String, AttributeValue>> getLastEvaluatedKey); static Key createKeyFromItem(T item, TableSchema<T> tableSchema, String indexName); static Key createKeyFromMap(Map<String, AttributeValue> itemMap,
TableSchema<?> tableSchema,
String indexName); static List<T> getItemsFromSupplier(List<Supplier<T>> itemSupplierList); static boolean isNullAttributeValue(AttributeValue attributeValue); }### Answer:
@Test public void cleanAttributeName_cleansSpecialCharacters() { String result = EnhancedClientUtils.cleanAttributeName("a*b.c-d:e#f"); assertThat(result).isEqualTo("a_b_c_d_e_f"); } |
### Question:
VersionedRecordExtension implements DynamoDbEnhancedClientExtension { public static Builder builder() { return new Builder(); } private VersionedRecordExtension(); static Builder builder(); @Override WriteModification beforeWrite(DynamoDbExtensionContext.BeforeWrite context); }### Answer:
@Test public void beforeRead_doesNotTransformObject() { FakeItem fakeItem = createUniqueFakeItem(); Map<String, AttributeValue> fakeItemMap = FakeItem.getTableSchema().itemToMap(fakeItem, true); ReadModification result = versionedRecordExtension.afterRead(DefaultDynamoDbExtensionContext .builder() .items(fakeItemMap) .tableMetadata(FakeItem.getTableMetadata()) .operationContext(PRIMARY_CONTEXT).build()); assertThat(result, is(ReadModification.builder().build())); } |
### Question:
Expression { public static String joinExpressions(String expression1, String expression2, String joinToken) { if (expression1 == null) { return expression2; } if (expression2 == null) { return expression1; } return "(" + expression1 + ")" + joinToken + "(" + expression2 + ")"; } private Expression(String expression,
Map<String, AttributeValue> expressionValues,
Map<String, String> expressionNames); static Builder builder(); static Expression join(Expression expression1, Expression expression2, String joinToken); static String joinExpressions(String expression1, String expression2, String joinToken); static Map<String, AttributeValue> joinValues(Map<String, AttributeValue> expressionValues1,
Map<String, AttributeValue> expressionValues2); static Map<String, String> joinNames(Map<String, String> expressionNames1,
Map<String, String> expressionNames2); String expression(); Map<String, AttributeValue> expressionValues(); Map<String, String> expressionNames(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void joinExpressions_correctlyJoins() { String result = Expression.joinExpressions("one", "two", " AND "); assertThat(result, is("(one) AND (two)")); } |
### Question:
StringUtils { public static String upperCase(final String str) { if (str == null) { return null; } return str.toUpperCase(Locale.ENGLISH); } private StringUtils(); static boolean isEmpty(final CharSequence cs); static boolean isBlank(final CharSequence cs); static boolean isNotBlank(final CharSequence cs); static String trim(final String str); static String trimToNull(final String str); static String trimToEmpty(final String str); static boolean equals(final String cs1, final String cs2); static String substring(final String str, int start); static String substring(final String str, int start, int end); static String upperCase(final String str); static String lowerCase(final String str); static String capitalize(final String str); static String uncapitalize(final String str); static String fromBytes(byte[] bytes, Charset charset); static boolean startsWithIgnoreCase(String str, String prefix); static String replacePrefixIgnoreCase(String str, String prefix, String replacement); static String replaceEach(final String text, final String[] searchList, final String[] replacementList); static Character findFirstOccurrence(String s, char ...charsToMatch); static boolean safeStringToBoolean(String value); }### Answer:
@Test public void testUpperCase() { assertNull(StringUtils.upperCase(null)); assertEquals("upperCase(String) failed", "FOO TEST THING", StringUtils.upperCase("fOo test THING")); assertEquals("upperCase(empty-string) failed", "", StringUtils.upperCase("")); } |
### Question:
StringUtils { public static String lowerCase(final String str) { if (str == null) { return null; } return str.toLowerCase(Locale.ENGLISH); } private StringUtils(); static boolean isEmpty(final CharSequence cs); static boolean isBlank(final CharSequence cs); static boolean isNotBlank(final CharSequence cs); static String trim(final String str); static String trimToNull(final String str); static String trimToEmpty(final String str); static boolean equals(final String cs1, final String cs2); static String substring(final String str, int start); static String substring(final String str, int start, int end); static String upperCase(final String str); static String lowerCase(final String str); static String capitalize(final String str); static String uncapitalize(final String str); static String fromBytes(byte[] bytes, Charset charset); static boolean startsWithIgnoreCase(String str, String prefix); static String replacePrefixIgnoreCase(String str, String prefix, String replacement); static String replaceEach(final String text, final String[] searchList, final String[] replacementList); static Character findFirstOccurrence(String s, char ...charsToMatch); static boolean safeStringToBoolean(String value); }### Answer:
@Test public void testLowerCase() { assertNull(StringUtils.lowerCase(null)); assertEquals("lowerCase(String) failed", "foo test thing", StringUtils.lowerCase("fOo test THING")); assertEquals("lowerCase(empty-string) failed", "", StringUtils.lowerCase("")); } |
### Question:
StringUtils { public static boolean startsWithIgnoreCase(String str, String prefix) { return str.regionMatches(true, 0, prefix, 0, prefix.length()); } private StringUtils(); static boolean isEmpty(final CharSequence cs); static boolean isBlank(final CharSequence cs); static boolean isNotBlank(final CharSequence cs); static String trim(final String str); static String trimToNull(final String str); static String trimToEmpty(final String str); static boolean equals(final String cs1, final String cs2); static String substring(final String str, int start); static String substring(final String str, int start, int end); static String upperCase(final String str); static String lowerCase(final String str); static String capitalize(final String str); static String uncapitalize(final String str); static String fromBytes(byte[] bytes, Charset charset); static boolean startsWithIgnoreCase(String str, String prefix); static String replacePrefixIgnoreCase(String str, String prefix, String replacement); static String replaceEach(final String text, final String[] searchList, final String[] replacementList); static Character findFirstOccurrence(String s, char ...charsToMatch); static boolean safeStringToBoolean(String value); }### Answer:
@Test public void testStartsWithIgnoreCase() { assertTrue(StringUtils.startsWithIgnoreCase("helloworld", "hello")); assertTrue(StringUtils.startsWithIgnoreCase("hELlOwOrlD", "hello")); assertFalse(StringUtils.startsWithIgnoreCase("hello", "world")); } |
### Question:
StringUtils { public static String replacePrefixIgnoreCase(String str, String prefix, String replacement) { return str.replaceFirst("(?i)" + prefix, replacement); } private StringUtils(); static boolean isEmpty(final CharSequence cs); static boolean isBlank(final CharSequence cs); static boolean isNotBlank(final CharSequence cs); static String trim(final String str); static String trimToNull(final String str); static String trimToEmpty(final String str); static boolean equals(final String cs1, final String cs2); static String substring(final String str, int start); static String substring(final String str, int start, int end); static String upperCase(final String str); static String lowerCase(final String str); static String capitalize(final String str); static String uncapitalize(final String str); static String fromBytes(byte[] bytes, Charset charset); static boolean startsWithIgnoreCase(String str, String prefix); static String replacePrefixIgnoreCase(String str, String prefix, String replacement); static String replaceEach(final String text, final String[] searchList, final String[] replacementList); static Character findFirstOccurrence(String s, char ...charsToMatch); static boolean safeStringToBoolean(String value); }### Answer:
@Test public void testReplacePrefixIgnoreCase() { assertEquals("lloWorld" ,replacePrefixIgnoreCase("helloWorld", "he", "")); assertEquals("lloWORld" ,replacePrefixIgnoreCase("helloWORld", "He", "")); assertEquals("llOwOrld" ,replacePrefixIgnoreCase("HEllOwOrld", "he", "")); } |
### Question:
StringUtils { public static Character findFirstOccurrence(String s, char ...charsToMatch) { int lowestIndex = Integer.MAX_VALUE; for (char toMatch : charsToMatch) { int currentIndex = s.indexOf(toMatch); if (currentIndex != -1 && currentIndex < lowestIndex) { lowestIndex = currentIndex; } } return lowestIndex == Integer.MAX_VALUE ? null : s.charAt(lowestIndex); } private StringUtils(); static boolean isEmpty(final CharSequence cs); static boolean isBlank(final CharSequence cs); static boolean isNotBlank(final CharSequence cs); static String trim(final String str); static String trimToNull(final String str); static String trimToEmpty(final String str); static boolean equals(final String cs1, final String cs2); static String substring(final String str, int start); static String substring(final String str, int start, int end); static String upperCase(final String str); static String lowerCase(final String str); static String capitalize(final String str); static String uncapitalize(final String str); static String fromBytes(byte[] bytes, Charset charset); static boolean startsWithIgnoreCase(String str, String prefix); static String replacePrefixIgnoreCase(String str, String prefix, String replacement); static String replaceEach(final String text, final String[] searchList, final String[] replacementList); static Character findFirstOccurrence(String s, char ...charsToMatch); static boolean safeStringToBoolean(String value); }### Answer:
@Test public void findFirstOccurrence() { assertEquals((Character) ':', StringUtils.findFirstOccurrence("abc:def/ghi:jkl/mno", ':', '/')); assertEquals((Character) ':', StringUtils.findFirstOccurrence("abc:def/ghi:jkl/mno", '/', ':')); }
@Test public void findFirstOccurrence_NoMatch() { assertNull(StringUtils.findFirstOccurrence("abc", ':')); } |
### Question:
StringUtils { public static boolean safeStringToBoolean(String value) { if (value.equalsIgnoreCase("true")) { return true; } else if (value.equalsIgnoreCase("false")) { return false; } throw new IllegalArgumentException("Value was defined as '" + value + "', but should be 'false' or 'true'"); } private StringUtils(); static boolean isEmpty(final CharSequence cs); static boolean isBlank(final CharSequence cs); static boolean isNotBlank(final CharSequence cs); static String trim(final String str); static String trimToNull(final String str); static String trimToEmpty(final String str); static boolean equals(final String cs1, final String cs2); static String substring(final String str, int start); static String substring(final String str, int start, int end); static String upperCase(final String str); static String lowerCase(final String str); static String capitalize(final String str); static String uncapitalize(final String str); static String fromBytes(byte[] bytes, Charset charset); static boolean startsWithIgnoreCase(String str, String prefix); static String replacePrefixIgnoreCase(String str, String prefix, String replacement); static String replaceEach(final String text, final String[] searchList, final String[] replacementList); static Character findFirstOccurrence(String s, char ...charsToMatch); static boolean safeStringToBoolean(String value); }### Answer:
@Test public void safeStringTooBoolean_mixedSpaceTrue_shouldReturnTrue() { assertTrue(StringUtils.safeStringToBoolean("TrUe")); }
@Test public void safeStringTooBoolean_mixedSpaceFalse_shouldReturnFalse() { assertFalse(StringUtils.safeStringToBoolean("fAlSE")); }
@Test(expected = IllegalArgumentException.class) public void safeStringTooBoolean_invalidValue_shouldThrowException() { assertFalse(StringUtils.safeStringToBoolean("foobar")); } |
### Question:
NumericUtils { public static Duration min(Duration a, Duration b) { return (a.compareTo(b) < 0) ? a : b; } private NumericUtils(); static int saturatedCast(long value); static Duration min(Duration a, Duration b); static Duration max(Duration a, Duration b); }### Answer:
@Test public void minTestDifferentDurations() { assertThat(min(SHORT_DURATION, LONG_DURATION), is(SHORT_DURATION)); }
@Test public void minTestDifferentDurationsReverse() { assertThat(min(LONG_DURATION, SHORT_DURATION), is(SHORT_DURATION)); }
@Test public void minTestSameDurations() { assertThat(min(SHORT_DURATION, SHORT_SAME_DURATION), is(SHORT_SAME_DURATION)); }
@Test public void minTestDifferentNegativeDurations() { assertThat(min(NEGATIVE_SHORT_DURATION, NEGATIVE_LONG_DURATION), is(NEGATIVE_LONG_DURATION)); }
@Test public void minTestNegativeSameDurations() { assertThat(min(NEGATIVE_SHORT_DURATION, NEGATIVE_SHORT_SAME_DURATION), is(NEGATIVE_SHORT_DURATION)); } |
### Question:
NumericUtils { public static Duration max(Duration a, Duration b) { return (a.compareTo(b) > 0) ? a : b; } private NumericUtils(); static int saturatedCast(long value); static Duration min(Duration a, Duration b); static Duration max(Duration a, Duration b); }### Answer:
@Test public void maxTestDifferentDurations() { assertThat(max(LONG_DURATION, SHORT_DURATION), is(LONG_DURATION)); }
@Test public void maxTestDifferentDurationsReverse() { assertThat(max(SHORT_DURATION, LONG_DURATION), is(LONG_DURATION)); }
@Test public void maxTestSameDurations() { assertThat(max(SHORT_DURATION, SHORT_SAME_DURATION), is(SHORT_SAME_DURATION)); }
@Test public void maxTestDifferentNegativeDurations() { assertThat(max(NEGATIVE_SHORT_DURATION, NEGATIVE_LONG_DURATION), is(NEGATIVE_SHORT_DURATION)); }
@Test public void maxTestNegativeSameDurations() { assertThat(max(NEGATIVE_SHORT_DURATION, NEGATIVE_SHORT_SAME_DURATION), is(NEGATIVE_SHORT_DURATION)); } |
### Question:
FunctionalUtils { public static <T> T invokeSafely(UnsafeSupplier<T> unsafeSupplier) { return safeSupplier(unsafeSupplier).get(); } private FunctionalUtils(); static void runAndLogError(Logger log, String errorMsg, UnsafeRunnable runnable); static Consumer<T> noOpConsumer(); static Runnable noOpRunnable(); static Consumer<I> safeConsumer(UnsafeConsumer<I> unsafeConsumer); static Function<T, R> safeFunction(UnsafeFunction<T, R> unsafeFunction); static Supplier<T> safeSupplier(UnsafeSupplier<T> unsafeSupplier); static Runnable safeRunnable(UnsafeRunnable unsafeRunnable); static Function<I, O> toFunction(Supplier<O> supplier); static T invokeSafely(UnsafeSupplier<T> unsafeSupplier); static void invokeSafely(UnsafeRunnable unsafeRunnable); }### Answer:
@Test public void checkedExceptionsAreConvertedToRuntimeExceptions() { assertThatExceptionOfType(RuntimeException.class) .isThrownBy(() -> invokeSafely(this::methodThatThrows)) .withCauseInstanceOf(Exception.class); }
@Test public void ioExceptionsAreConvertedToUncheckedIoExceptions() { assertThatExceptionOfType(UncheckedIOException.class) .isThrownBy(() -> invokeSafely(this::methodThatThrowsIOException)) .withCauseInstanceOf(IOException.class); }
@Test public void runtimeExceptionsAreNotWrapped() { assertThatExceptionOfType(RuntimeException.class) .isThrownBy(() -> invokeSafely(this::methodWithCheckedSignatureThatThrowsRuntimeException)) .withNoCause(); }
@Test public void interruptedExceptionShouldSetInterruptedOnTheThread() { assertThatExceptionOfType(RuntimeException.class) .isThrownBy(() -> invokeSafely(this::methodThatThrowsInterruptedException)) .withCauseInstanceOf(InterruptedException.class); assertThat(Thread.currentThread().isInterrupted()).isTrue(); Thread.interrupted(); } |
### Question:
FunctionalUtils { public static <I> Consumer<I> safeConsumer(UnsafeConsumer<I> unsafeConsumer) { return (input) -> { try { unsafeConsumer.accept(input); } catch (Exception e) { throw asRuntimeException(e); } }; } private FunctionalUtils(); static void runAndLogError(Logger log, String errorMsg, UnsafeRunnable runnable); static Consumer<T> noOpConsumer(); static Runnable noOpRunnable(); static Consumer<I> safeConsumer(UnsafeConsumer<I> unsafeConsumer); static Function<T, R> safeFunction(UnsafeFunction<T, R> unsafeFunction); static Supplier<T> safeSupplier(UnsafeSupplier<T> unsafeSupplier); static Runnable safeRunnable(UnsafeRunnable unsafeRunnable); static Function<I, O> toFunction(Supplier<O> supplier); static T invokeSafely(UnsafeSupplier<T> unsafeSupplier); static void invokeSafely(UnsafeRunnable unsafeRunnable); }### Answer:
@Test public void canUseConsumerThatThrowsCheckedExceptionInLambda() { Stream.of(DONT_THROW_EXCEPTION).forEach(safeConsumer(this::consumerMethodWithChecked)); }
@Test public void exceptionsForConsumersAreConverted() { assertThatExceptionOfType(RuntimeException.class) .isThrownBy(() -> Stream.of(THROW_EXCEPTION).forEach(safeConsumer(this::consumerMethodWithChecked))) .withCauseExactlyInstanceOf(Exception.class); } |
### Question:
FunctionalUtils { public static <T, R> Function<T, R> safeFunction(UnsafeFunction<T, R> unsafeFunction) { return t -> { try { return unsafeFunction.apply(t); } catch (Exception e) { throw asRuntimeException(e); } }; } private FunctionalUtils(); static void runAndLogError(Logger log, String errorMsg, UnsafeRunnable runnable); static Consumer<T> noOpConsumer(); static Runnable noOpRunnable(); static Consumer<I> safeConsumer(UnsafeConsumer<I> unsafeConsumer); static Function<T, R> safeFunction(UnsafeFunction<T, R> unsafeFunction); static Supplier<T> safeSupplier(UnsafeSupplier<T> unsafeSupplier); static Runnable safeRunnable(UnsafeRunnable unsafeRunnable); static Function<I, O> toFunction(Supplier<O> supplier); static T invokeSafely(UnsafeSupplier<T> unsafeSupplier); static void invokeSafely(UnsafeRunnable unsafeRunnable); }### Answer:
@Test public void canUseFunctionThatThrowsCheckedExceptionInLambda() { Optional<String> result = Stream.of(DONT_THROW_EXCEPTION).map(safeFunction(this::functionMethodWithChecked)).findFirst(); assertThat(result).isPresent().contains("Hello"); }
@Test @SuppressWarnings("ResultOfMethodCallIgnored") public void exceptionsForFunctionsAreConverted() { assertThatExceptionOfType(RuntimeException.class) .isThrownBy(() -> Stream.of(THROW_EXCEPTION).map(safeFunction(this::functionMethodWithChecked)).findFirst()) .withCauseExactlyInstanceOf(Exception.class); } |
### Question:
Pair { public static <LeftT, RightT> Pair<LeftT, RightT> of(LeftT left, RightT right) { return new Pair<>(left, right); } private Pair(LeftT left, RightT right); LeftT left(); RightT right(); ReturnT apply(BiFunction<LeftT, RightT, ReturnT> function); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Pair<LeftT, RightT> of(LeftT left, RightT right); }### Answer:
@Test public void equalsMethodWorksAsExpected() { Pair foo = Pair.of("Foo", 50); assertThat(foo).isEqualTo(Pair.of("Foo", 50)); assertThat(foo).isNotEqualTo(Pair.of("Foo-bar", 50)); }
@Test public void canBeUseAsMapKey() { Map<Pair<String, Integer>, String> map = new HashMap<>(); map.put(Pair.of("Hello", 100), "World"); assertThat(map.get(Pair.of("Hello", 100))).isEqualTo("World"); } |
### Question:
Either { public static <L, R> Either<L, R> left(L value) { return new Either<>(Optional.of(value), Optional.empty()); } private Either(Optional<L> l, Optional<R> r); T map(
Function<? super L, ? extends T> lFunc,
Function<? super R, ? extends T> rFunc); Either<T, R> mapLeft(Function<? super L, ? extends T> lFunc); Either<L, T> mapRight(Function<? super R, ? extends T> rFunc); void apply(Consumer<? super L> lFunc, Consumer<? super R> rFunc); static Either<L, R> left(L value); static Either<L, R> right(R value); Optional<L> left(); Optional<R> right(); static Optional<Either<L, R>> fromNullable(L left, R right); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test(expected = NullPointerException.class) public void leftValueNull_ThrowsException() { Either.left(null); } |
### Question:
GetObjectPresignRequest extends PresignRequest implements ToCopyableBuilder<GetObjectPresignRequest.Builder, GetObjectPresignRequest> { @Override public Builder toBuilder() { return new DefaultBuilder(this); } private GetObjectPresignRequest(DefaultBuilder builder); static Builder builder(); GetObjectRequest getObjectRequest(); @Override Builder toBuilder(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void toBuilder() { GetObjectPresignRequest getObjectPresignRequest = GetObjectPresignRequest.builder() .getObjectRequest(GET_OBJECT_REQUEST) .signatureDuration(Duration.ofSeconds(123L)) .build(); GetObjectPresignRequest otherGetObjectPresignRequest = getObjectPresignRequest.toBuilder().build(); assertThat(otherGetObjectPresignRequest.getObjectRequest()).isEqualTo(GET_OBJECT_REQUEST); assertThat(otherGetObjectPresignRequest.signatureDuration()).isEqualTo(Duration.ofSeconds(123L)); } |
### Question:
Either { public static <L, R> Either<L, R> right(R value) { return new Either<>(Optional.empty(), Optional.of(value)); } private Either(Optional<L> l, Optional<R> r); T map(
Function<? super L, ? extends T> lFunc,
Function<? super R, ? extends T> rFunc); Either<T, R> mapLeft(Function<? super L, ? extends T> lFunc); Either<L, T> mapRight(Function<? super R, ? extends T> rFunc); void apply(Consumer<? super L> lFunc, Consumer<? super R> rFunc); static Either<L, R> left(L value); static Either<L, R> right(R value); Optional<L> left(); Optional<R> right(); static Optional<Either<L, R>> fromNullable(L left, R right); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test(expected = NullPointerException.class) public void rightValueNull_ThrowsException() { Either.right(null); } |
### Question:
Either { public static <L, R> Optional<Either<L, R>> fromNullable(L left, R right) { if (left != null && right == null) { return Optional.of(left(left)); } if (left == null && right != null) { return Optional.of(right(right)); } if (left == null && right == null) { return Optional.empty(); } throw new IllegalArgumentException(String.format("Only one of either left or right should be non-null. " + "Got (left: %s, right: %s)", left, right)); } private Either(Optional<L> l, Optional<R> r); T map(
Function<? super L, ? extends T> lFunc,
Function<? super R, ? extends T> rFunc); Either<T, R> mapLeft(Function<? super L, ? extends T> lFunc); Either<L, T> mapRight(Function<? super R, ? extends T> rFunc); void apply(Consumer<? super L> lFunc, Consumer<? super R> rFunc); static Either<L, R> left(L value); static Either<L, R> right(R value); Optional<L> left(); Optional<R> right(); static Optional<Either<L, R>> fromNullable(L left, R right); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void fromNullable() { assertThat(Either.fromNullable("left", null)).contains(Either.left("left")); assertThat(Either.fromNullable(null, "right")).contains(Either.right("right")); assertThat(Either.fromNullable(null, null)).isEmpty(); assertThatThrownBy(() -> Either.fromNullable("left", "right")).isInstanceOf(IllegalArgumentException.class); } |
### Question:
CompletableFutureUtils { public static <T> CompletableFuture<T> forwardExceptionTo(CompletableFuture<T> src, CompletableFuture<?> dst) { src.whenComplete((r, e) -> { if (e != null) { dst.completeExceptionally(e); } }); return src; } private CompletableFutureUtils(); static CompletableFuture<U> failedFuture(Throwable t); static CompletionException errorAsCompletionException(Throwable t); static CompletableFuture<T> forwardExceptionTo(CompletableFuture<T> src, CompletableFuture<?> dst); }### Answer:
@Test(timeout = 1000) public void testForwardException() { CompletableFuture src = new CompletableFuture(); CompletableFuture dst = new CompletableFuture(); Exception e = new RuntimeException("BOOM"); CompletableFutureUtils.forwardExceptionTo(src, dst); src.completeExceptionally(e); try { dst.join(); fail(); } catch (Throwable t) { assertThat(t.getCause()).isEqualTo(e); } } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.