method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
MetaStoreMappingImpl implements MetaStoreMapping { @Override public void close() throws IOException { client.close(); } MetaStoreMappingImpl(
String databasePrefix,
String name,
CloseableThriftHiveMetastoreIface client,
AccessControlHandler accessControlHandler,
ConnectionType connectionType,
long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer:
@Test public void close() throws IOException { metaStoreMapping.close(); verify(client).close(); } |
### Question:
MetaStoreMappingImpl implements MetaStoreMapping { @Override public boolean isAvailable() { try { boolean isOpen = client.isOpen(); if (isOpen && connectionType == ConnectionType.TUNNELED) { client.getStatus(); } return isOpen; } catch (Exception e) { log.error("Metastore Mapping {} unavailable", name, e); return false; } } MetaStoreMappingImpl(
String databasePrefix,
String name,
CloseableThriftHiveMetastoreIface client,
AccessControlHandler accessControlHandler,
ConnectionType connectionType,
long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer:
@Test public void isAvailable() { when(client.isOpen()).thenReturn(true); assertThat(metaStoreMapping.isAvailable(), is(true)); }
@Test public void isNotAvailable() { when(client.isOpen()).thenReturn(false); assertThat(metaStoreMapping.isAvailable(), is(false)); }
@Test public void isAvailableTunnelled() throws Exception { when(client.isOpen()).thenReturn(true); assertThat(tunneledMetaStoreMapping.isAvailable(), is(true)); verify(client).getStatus(); }
@Test public void isNotAvailableTunnelled() throws Exception { when(client.isOpen()).thenReturn(false); assertThat(tunneledMetaStoreMapping.isAvailable(), is(false)); verify(client, never()).getStatus(); }
@Test public void isNotAvailableClientErrorTunnelled() throws Exception { when(client.isOpen()).thenReturn(true); when(client.getStatus()).thenThrow(new TException("ERROR")); assertThat(tunneledMetaStoreMapping.isAvailable(), is(false)); } |
### Question:
MetaStoreMappingImpl implements MetaStoreMapping { @Override public MetaStoreMapping checkWritePermissions(String databaseName) { if (!accessControlHandler.hasWritePermission(databaseName)) { throw new NotAllowedException( "You cannot perform this operation on the virtual database '" + databaseName + "'."); } return this; } MetaStoreMappingImpl(
String databasePrefix,
String name,
CloseableThriftHiveMetastoreIface client,
AccessControlHandler accessControlHandler,
ConnectionType connectionType,
long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer:
@Test public void checkWritePermissions() { String databaseName = "db"; when(accessControlHandler.hasWritePermission(databaseName)).thenReturn(true); assertThat(metaStoreMapping.checkWritePermissions(databaseName), is(metaStoreMapping)); }
@Test(expected = NotAllowedException.class) public void checkWritePermissionsThrowsException() { String databaseName = "db"; when(accessControlHandler.hasWritePermission(databaseName)).thenReturn(false); metaStoreMapping.checkWritePermissions(databaseName); } |
### Question:
MetaStoreMappingImpl implements MetaStoreMapping { @Override public void createDatabase(Database database) throws AlreadyExistsException, InvalidObjectException, MetaException, TException { if (accessControlHandler.hasCreatePermission()) { getClient().create_database(database); accessControlHandler.databaseCreatedNotification(database.getName()); } else { throw new NotAllowedException("You cannot create the database '" + database.getName() + "'."); } } MetaStoreMappingImpl(
String databasePrefix,
String name,
CloseableThriftHiveMetastoreIface client,
AccessControlHandler accessControlHandler,
ConnectionType connectionType,
long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer:
@Test public void createDatabase() throws Exception { when(database.getName()).thenReturn("db"); when(accessControlHandler.hasCreatePermission()).thenReturn(true); metaStoreMapping.createDatabase(database); verify(client).create_database(database); verify(accessControlHandler).databaseCreatedNotification("db"); }
@Test public void createDatabasePermissionDenied() throws Exception { when(database.getName()).thenReturn("db"); when(accessControlHandler.hasCreatePermission()).thenReturn(false); try { metaStoreMapping.createDatabase(database); fail("Should have thrown exception"); } catch (NotAllowedException e) { verify(client, never()).create_database(database); verify(accessControlHandler, never()).databaseCreatedNotification("db"); } } |
### Question:
AbstractMetaStore { public static PrimaryMetaStore newPrimaryInstance( String name, String remoteMetaStoreUris, AccessControlType accessControlType) { return new PrimaryMetaStore(name, remoteMetaStoreUris, accessControlType); } AbstractMetaStore(); AbstractMetaStore(String name, String remoteMetaStoreUris, AccessControlType accessControlType); AbstractMetaStore(
String name,
String remoteMetaStoreUris,
AccessControlType accessControlType,
List<String> writableDatabaseWhitelist); static FederatedMetaStore newFederatedInstance(String name, String remoteMetaStoreUris); static PrimaryMetaStore newPrimaryInstance(
String name,
String remoteMetaStoreUris,
AccessControlType accessControlType); static PrimaryMetaStore newPrimaryInstance(String name, String remoteMetaStoreUris); String getDatabasePrefix(); void setDatabasePrefix(String databasePrefix); String getName(); void setName(String name); String getRemoteMetaStoreUris(); void setRemoteMetaStoreUris(String remoteMetaStoreUris); MetastoreTunnel getMetastoreTunnel(); void setMetastoreTunnel(MetastoreTunnel metastoreTunnel); ConnectionType getConnectionType(); abstract FederationType getFederationType(); AccessControlType getAccessControlType(); void setAccessControlType(AccessControlType accessControlType); List<String> getWritableDatabaseWhiteList(); void setWritableDatabaseWhiteList(List<String> writableDatabaseWhitelist); long getLatency(); void setLatency(long latency); List<String> getMappedDatabases(); void setMappedDatabases(List<String> mappedDatabases); Map<String, String> getDatabaseNameMapping(); void setDatabaseNameMapping(Map<String, String> databaseNameMapping); @Transient HashBiMap<String, String> getDatabaseNameBiMapping(); @Transient MetaStoreStatus getStatus(); @Transient void setStatus(MetaStoreStatus status); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer:
@Test public void newPrimaryInstance() { AccessControlType access = AccessControlType.READ_AND_WRITE_AND_CREATE; PrimaryMetaStore primaryMetaStore = AbstractMetaStore.newPrimaryInstance(name, remoteMetaStoreUri, access); assertThat(primaryMetaStore.getName(), is(name)); assertThat(primaryMetaStore.getRemoteMetaStoreUris(), is(remoteMetaStoreUri)); assertThat(primaryMetaStore.getAccessControlType(), is(access)); } |
### Question:
MetaStoreMappingImpl implements MetaStoreMapping { @Override public long getLatency() { return latency; } MetaStoreMappingImpl(
String databasePrefix,
String name,
CloseableThriftHiveMetastoreIface client,
AccessControlHandler accessControlHandler,
ConnectionType connectionType,
long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer:
@Test public void getLatency() { assertThat(metaStoreMapping.getLatency(), is(LATENCY)); } |
### Question:
FederatedMetaStore extends AbstractMetaStore { @Override public FederationType getFederationType() { return FederationType.FEDERATED; } FederatedMetaStore(); FederatedMetaStore(String name, String remoteMetaStoreUris); FederatedMetaStore(String name, String remoteMetaStoreUris, AccessControlType accessControlType); FederatedMetaStore(FederatedMetaStore federatedMetaStore); FederatedMetaStore(
String name,
String remoteMetaStoreUris,
AccessControlType accessControlType,
List<String> writableDatabaseWhiteList); @Override FederationType getFederationType(); @Override String getDatabasePrefix(); }### Answer:
@Test public void testFederationType() { assertThat(metaStore.getFederationType(), is(FederationType.FEDERATED)); } |
### Question:
FederatedMetaStore extends AbstractMetaStore { @Override public String getDatabasePrefix() { String prefix = super.getDatabasePrefix(); if (prefix == null) { prefix = getName() + "_"; } return prefix; } FederatedMetaStore(); FederatedMetaStore(String name, String remoteMetaStoreUris); FederatedMetaStore(String name, String remoteMetaStoreUris, AccessControlType accessControlType); FederatedMetaStore(FederatedMetaStore federatedMetaStore); FederatedMetaStore(
String name,
String remoteMetaStoreUris,
AccessControlType accessControlType,
List<String> writableDatabaseWhiteList); @Override FederationType getFederationType(); @Override String getDatabasePrefix(); }### Answer:
@Test public void emptyDatabasePrefix() { metaStore.setDatabasePrefix(""); Set<ConstraintViolation<FederatedMetaStore>> violations = validator.validate(metaStore); assertThat(violations.size(), is(0)); assertThat(metaStore.getDatabasePrefix(), is("")); }
@Test public void nonEmptyDatabasePrefix() { metaStore.setDatabasePrefix("override"); Set<ConstraintViolation<FederatedMetaStore>> violations = validator.validate(metaStore); assertThat(violations.size(), is(0)); assertThat("override", is(metaStore.getDatabasePrefix())); }
@Test public void nullDatabasePrefix() { metaStore.setDatabasePrefix(null); Set<ConstraintViolation<FederatedMetaStore>> violations = validator.validate(metaStore); assertThat(violations.size(), is(0)); assertThat("name_", is(metaStore.getDatabasePrefix())); } |
### Question:
ValidationError { public void addValidationError(String error) { errors.add(error); } private ValidationError(String errorMessage); static ValidationErrorBuilder builder(); static ValidationErrorBuilder builder(Errors errors); void addValidationError(String error); List<String> getErrors(); String getErrorMessage(); }### Answer:
@Test public void addValidationError() { String errorMessage = "Another error"; ValidationError validationError = ValidationError.builder().build(); validationError.addValidationError(errorMessage); List<String> expectedErrors = Collections.singletonList(errorMessage); assertThat(validationError.getErrorMessage(), is("Validation failed")); assertThat(validationError.getErrors(), is(expectedErrors)); } |
### Question:
FederationsAdminController { @RequestMapping(method = RequestMethod.POST) public void add(@Validated @RequestBody AbstractMetaStore federatedMetaStore) { federationService.register(federatedMetaStore); } @Autowired FederationsAdminController(@Qualifier("populateStatusFederationService") FederationService federationService); @RequestMapping(method = RequestMethod.GET) @ResponseBody List<AbstractMetaStore> federations(); @RequestMapping(method = RequestMethod.GET, path = "/{name}") @ResponseBody AbstractMetaStore read(@NotNull @PathVariable String name); @RequestMapping(method = RequestMethod.POST) void add(@Validated @RequestBody AbstractMetaStore federatedMetaStore); @RequestMapping(method = RequestMethod.DELETE, path = "/{name}") void remove(@NotNull @PathVariable String name); @ExceptionHandler(ValidationException.class) @ResponseStatus(value = HttpStatus.BAD_REQUEST) ValidationError handleValidationException(HttpServletRequest req, ValidationException exception); @ExceptionHandler(MethodArgumentNotValidException.class) @ResponseStatus(value = HttpStatus.BAD_REQUEST) ValidationError handleException(HttpServletRequest req, MethodArgumentNotValidException exception); }### Answer:
@Test public void add() throws Exception { String content = Jackson2ObjectMapperBuilder.json().build().writeValueAsString(metastore); mockMvc .perform(post("/api/admin/federations/").contentType(MediaType.APPLICATION_JSON_UTF8).content(content)) .andExpect(status().isOk()); verify(populateStatusFederationService).register(metastore); } |
### Question:
GrammarUtils { @VisibleForTesting static String[] splitPattern(String prefix, String pattern) { if (pattern.startsWith(prefix)) { return new String[] { prefix, pattern.substring(prefix.length()) }; } String subPattern = pattern; int index = pattern.length(); while (index >= 0) { String subPatternRegex = subPattern.replaceAll("\\*", ".*"); if (prefix.matches(subPatternRegex)) { return new String[] { subPattern, pattern.substring(subPattern.length() - 1) }; } if (subPattern.endsWith("*")) { subPattern = subPattern.substring(0, subPattern.length() - 1); } index = subPattern.lastIndexOf("*"); if (index >= 0) { subPattern = subPattern.substring(0, index + 1); } } return new String[] {}; } private GrammarUtils(); static Map<String, String> selectMatchingPrefixes(Set<String> prefixes, String dbPatterns); }### Answer:
@Test public void emptySubPattern() { String[] patternParts = GrammarUtils.splitPattern(PREFIX, ""); assertThat(patternParts, IsArrayWithSize.emptyArray()); }
@Test public void basicSubPatternMatchingPrefix() { String[] patternParts = GrammarUtils.splitPattern(PREFIX, "waggle_"); assertThat(patternParts[0], is(PREFIX)); assertThat(patternParts[1], is("")); }
@Test public void basicSubPatternNotMatchingPrefix() { String[] patternParts = GrammarUtils.splitPattern("prefix", "waggle_"); assertThat(patternParts, IsArrayWithSize.emptyArray()); }
@Test public void subPatternMatchesEverything() { String[] patternParts = GrammarUtils.splitPattern(PREFIX, "*"); assertThat(patternParts[0], is("*")); assertThat(patternParts[1], is("*")); }
@Test public void subPatternMatchesAllTables() { String[] patternParts = GrammarUtils.splitPattern(PREFIX, "waggle_*"); assertThat(patternParts[0], is(PREFIX)); assertThat(patternParts[1], is("*")); }
@Test public void subPatternMatchesAllSpecificTables() { String[] patternParts = GrammarUtils.splitPattern(PREFIX, "waggle_*base"); assertThat(patternParts[0], is(PREFIX)); assertThat(patternParts[1], is("*base")); }
@Test public void subPatternMatchesDatabaseAndAllSpecificTables() { String[] patternParts = GrammarUtils.splitPattern(PREFIX, "wag*base"); assertThat(patternParts[0], is("wag*")); assertThat(patternParts[1], is("*base")); } |
### Question:
MonitoredAspect { @Around("execution(public * *(..)) && within(@com.hotels.bdp.waggledance.metrics.Monitored *)") public Object monitor(ProceedingJoinPoint pjp) throws Throwable { return monitor(pjp, null); } @Around("execution(* *(..)) && within(@com.hotels.bdp.waggledance.metrics.Monitored *)") Object monitor(ProceedingJoinPoint pjp); @Around("@annotation(monitored)") Object monitor(ProceedingJoinPoint pjp, Monitored monitored); }### Answer:
@Test public void specialChars() throws Throwable { reset(signature); when(signature.getDeclaringTypeName()).thenReturn("$Type<Enc>$"); when(signature.getName()).thenReturn("<method$x>"); aspect.monitor(pjp, monitored); RequiredSearch rs = meterRegistry.get("counter._Type_Enc__._method_x_.all.calls"); assertThat(rs.counter().count(), is(1.0)); rs = meterRegistry.get("counter._Type_Enc__._method_x_.all.success"); assertThat(rs.counter().count(), is(1.0)); rs = meterRegistry.get("timer._Type_Enc__._method_x_.all.duration"); assertThat(rs.timer().count(), is(1L)); }
@Test public void monitorFailures() throws Throwable { when(pjp.proceed()).thenThrow(new ClassCastException()); try { aspect.monitor(pjp, monitored); } catch (ClassCastException e) { } RequiredSearch rs = meterRegistry.get("counter.Type_Anonymous.myMethod.all.calls"); assertThat(rs.counter().count(), is(1.0)); rs = meterRegistry.get("counter.Type_Anonymous.myMethod.all.failure"); assertThat(rs.counter().count(), is(1.0)); rs = meterRegistry.get("timer.Type_Anonymous.myMethod.all.duration"); assertThat(rs.timer().count(), is(1L)); }
@Test public void monitorSuccesses() throws Throwable { aspect.monitor(pjp, monitored); RequiredSearch rs = meterRegistry.get("counter.Type_Anonymous.myMethod.all.calls"); assertThat(rs.counter().count(), is(1.0)); rs = meterRegistry.get("counter.Type_Anonymous.myMethod.all.success"); assertThat(rs.counter().count(), is(1.0)); rs = meterRegistry.get("timer.Type_Anonymous.myMethod.all.duration"); assertThat(rs.timer().count(), is(1L)); }
@Test public void monitorFailuresForSpecificMetastore() throws Throwable { CurrentMonitoredMetaStoreHolder.monitorMetastore("metastoreName"); when(pjp.proceed()).thenThrow(new ClassCastException()); try { aspect.monitor(pjp, monitored); } catch (ClassCastException e) { } RequiredSearch rs = meterRegistry.get("counter.Type_Anonymous.myMethod.metastoreName.calls"); assertThat(rs.counter().count(), is(1.0)); rs = meterRegistry.get("counter.Type_Anonymous.myMethod.metastoreName.failure"); assertThat(rs.counter().count(), is(1.0)); rs = meterRegistry.get("timer.Type_Anonymous.myMethod.metastoreName.duration"); assertThat(rs.timer().count(), is(1L)); }
@Test public void monitorSuccessesForSpecificMetastore() throws Throwable { CurrentMonitoredMetaStoreHolder.monitorMetastore("metastoreName"); aspect.monitor(pjp, monitored); RequiredSearch rs = meterRegistry.get("counter.Type_Anonymous.myMethod.metastoreName.calls"); assertThat(rs.counter().count(), is(1.0)); rs = meterRegistry.get("counter.Type_Anonymous.myMethod.metastoreName.success"); assertThat(rs.counter().count(), is(1.0)); rs = meterRegistry.get("timer.Type_Anonymous.myMethod.metastoreName.duration"); assertThat(rs.timer().count(), is(1L)); } |
### Question:
PrimaryMetaStore extends AbstractMetaStore { @NotNull @Override public String getDatabasePrefix() { String prefix = super.getDatabasePrefix(); if (prefix == null) { prefix = EMPTY_PREFIX; } return prefix; } PrimaryMetaStore(); PrimaryMetaStore(
String name,
String remoteMetaStoreUris,
AccessControlType accessControlType,
String... writableDatabaseWhitelist); PrimaryMetaStore(
String name,
String remoteMetaStoreUris,
AccessControlType accessControlType,
List<String> writableDatabaseWhitelist); @Override FederationType getFederationType(); @NotNull @Override String getDatabasePrefix(); }### Answer:
@Test public void emptyDatabasePrefix() { metaStore.setDatabasePrefix(""); Set<ConstraintViolation<PrimaryMetaStore>> violations = validator.validate(metaStore); assertThat(violations.size(), is(0)); assertThat(metaStore.getDatabasePrefix(), is("")); }
@Test public void nullDatabasePrefix() { metaStore.setDatabasePrefix(null); Set<ConstraintViolation<PrimaryMetaStore>> violations = validator.validate(metaStore); assertThat(violations.size(), is(0)); assertThat(metaStore.getDatabasePrefix(), is("")); }
@Test public void nonEmptyDatabasePrefix() { String prefix = "abc"; metaStore.setDatabasePrefix(prefix); Set<ConstraintViolation<PrimaryMetaStore>> violations = validator.validate(metaStore); assertThat(violations.size(), is(0)); assertThat(metaStore.getDatabasePrefix(), is(prefix)); } |
### Question:
StaticDatabaseMappingService implements MappingEventListener { @Override public DatabaseMapping databaseMapping(@NotNull String databaseName) throws NoSuchObjectException { DatabaseMapping databaseMapping = mappingsByDatabaseName.get(databaseName.toLowerCase(Locale.ROOT)); if (databaseMapping != null) { LOG .debug("Database Name `{}` maps to metastore with name '{}'", databaseName, databaseMapping.getMetastoreMappingName()); if (includeInResults(databaseMapping)) { return databaseMapping; } } LOG.debug("Database Name `{}` not mapped", databaseName); throw new NoSuchObjectException("Primary metastore does not have database " + databaseName); } StaticDatabaseMappingService(
MetaStoreMappingFactory metaStoreMappingFactory,
List<AbstractMetaStore> initialMetastores,
QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer:
@Test public void databaseMappingPrimary() throws NoSuchObjectException { DatabaseMapping databaseMapping = service.databaseMapping(PRIMARY_DB); assertThat(databaseMapping.getMetastoreMappingName(), is(PRIMARY_NAME)); assertTrue(databaseMapping instanceof DatabaseMappingImpl); }
@Test(expected = NoSuchObjectException.class) public void databaseMappingPrimaryNotMatching() throws NoSuchObjectException { service.databaseMapping("some_unknown_non_federated_db"); }
@Test public void databaseMappingFederated() throws NoSuchObjectException { service.databaseMapping(FEDERATED_DB); DatabaseMapping databaseMapping = service.databaseMapping(FEDERATED_DB); assertThat(databaseMapping.getMetastoreMappingName(), is(FEDERATED_NAME)); assertTrue(databaseMapping instanceof DatabaseMappingImpl); } |
### Question:
StaticDatabaseMappingService implements MappingEventListener { @Override public void onRegister(AbstractMetaStore metaStore) { synchronized (mappingsByMetaStoreName) { if (mappingsByMetaStoreName.containsKey(metaStore.getName())) { throw new WaggleDanceException( "Metastore with name '" + metaStore.getName() + "' already registered, remove old one first or update"); } if ((metaStore.getFederationType() == FederationType.PRIMARY) && (primaryDatabaseMapping != null)) { throw new WaggleDanceException("Primary metastore already registered, remove old one first or update"); } add(metaStore); } } StaticDatabaseMappingService(
MetaStoreMappingFactory metaStoreMappingFactory,
List<AbstractMetaStore> initialMetastores,
QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer:
@Test(expected = WaggleDanceException.class) public void onRegisterPrimaryThrowsExceptionDueToExistingPrimary() { PrimaryMetaStore newMetastore = newPrimaryInstance(PRIMARY_NAME, "abc"); service.onRegister(newMetastore); }
@Test public void onRegister() throws TException { FederatedMetaStore newMetastore = newFederatedInstanceWithClient("fed1", "abc", Lists.newArrayList("db1"), true); service.onRegister(newMetastore); DatabaseMapping databaseMapping = service.databaseMapping("db1"); assertThat(databaseMapping.getMetastoreMappingName(), is("fed1")); assertTrue(databaseMapping instanceof DatabaseMappingImpl); }
@Test(expected = WaggleDanceException.class) public void onRegisterPreviousMappingThrowsException() { FederatedMetaStore newMetastore = newFederatedInstance(FEDERATED_NAME, "abc"); service.onRegister(newMetastore); }
@Test(expected = WaggleDanceException.class) public void onRegisterAnotherPrimaryThrowsException() { PrimaryMetaStore newMetastore = newPrimaryInstance("new_name", "new_uri"); service.onRegister(newMetastore); } |
### Question:
StaticDatabaseMappingService implements MappingEventListener { @Override public void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore) { synchronized (mappingsByMetaStoreName) { remove(oldMetaStore); add(newMetaStore); } } StaticDatabaseMappingService(
MetaStoreMappingFactory metaStoreMappingFactory,
List<AbstractMetaStore> initialMetastores,
QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer:
@Test public void onUpdate() throws TException { FederatedMetaStore newMetastore = newFederatedInstanceWithClient(FEDERATED_NAME, "abc", Lists.newArrayList("db1", "federated_DB"), true); service.onUpdate(federatedMetastore, newMetastore); DatabaseMapping databaseMapping = service.databaseMapping("db1"); assertThat(databaseMapping.getMetastoreMappingName(), is(FEDERATED_NAME)); assertTrue(databaseMapping instanceof DatabaseMappingImpl); databaseMapping = service.databaseMapping(FEDERATED_DB); assertThat(databaseMapping.getMetastoreMappingName(), is(FEDERATED_NAME)); assertTrue(databaseMapping instanceof DatabaseMappingImpl); } |
### Question:
StaticDatabaseMappingService implements MappingEventListener { @Override public void onUnregister(AbstractMetaStore metaStore) { synchronized (mappingsByMetaStoreName) { remove(metaStore); } } StaticDatabaseMappingService(
MetaStoreMappingFactory metaStoreMappingFactory,
List<AbstractMetaStore> initialMetastores,
QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer:
@Test(expected = NoSuchObjectException.class) public void onUnregister() throws NoSuchObjectException { service.onUnregister(federatedMetastore); service.databaseMapping(FEDERATED_DB); } |
### Question:
StaticDatabaseMappingService implements MappingEventListener { @Override public DatabaseMapping primaryDatabaseMapping() { if (primaryDatabaseMapping == null) { throw new NoPrimaryMetastoreException("Waggle Dance error no primary database mapping available"); } return primaryDatabaseMapping; } StaticDatabaseMappingService(
MetaStoreMappingFactory metaStoreMappingFactory,
List<AbstractMetaStore> initialMetastores,
QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer:
@Test public void primaryDatabaseMapping() { DatabaseMapping mapping = service.primaryDatabaseMapping(); assertThat(mapping.getClient(), is(primaryDatabaseClient)); } |
### Question:
StaticDatabaseMappingService implements MappingEventListener { @Override public void close() throws IOException { if (mappingsByMetaStoreName != null) { for (MetaStoreMapping metaStoreMapping : mappingsByMetaStoreName.values()) { metaStoreMapping.close(); } } } StaticDatabaseMappingService(
MetaStoreMappingFactory metaStoreMappingFactory,
List<AbstractMetaStore> initialMetastores,
QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer:
@Test public void close() throws IOException { service.close(); verify(metaStoreMappingPrimary).close(); verify(metaStoreMappingFederated).close(); } |
### Question:
PollingFederationService { public void poll() { log.debug("polling status"); Map<String, MetaStoreStatus> current = new HashMap<>(); List<AbstractMetaStore> metastores = populateStatusFederationService.getAll(); for (AbstractMetaStore metaStore : metastores) { current.put(metaStore.getName(), metaStore.getStatus()); MetaStoreStatus previousMetastoreStatus = previous.get(metaStore.getName()); if (previousMetastoreStatus != null) { if (previousMetastoreStatus != metaStore.getStatus()) { populateStatusFederationService.update(metaStore, metaStore); } } } previous = current; } PollingFederationService(PopulateStatusFederationService populateStatusFederationService); void poll(); }### Answer:
@Test public void pollNotifyOnStateChange() throws Exception { AbstractMetaStore primary = AbstractMetaStore.newPrimaryInstance("p", "uri"); AbstractMetaStore federate = AbstractMetaStore.newFederatedInstance("f", "uri"); primary.setStatus(MetaStoreStatus.AVAILABLE); federate.setStatus(MetaStoreStatus.AVAILABLE); List<AbstractMetaStore> metastores = Lists.newArrayList(primary, federate); when(populateStatusFederationService.getAll()).thenReturn(metastores); service.poll(); verify(populateStatusFederationService, never()).update(primary, primary); verify(populateStatusFederationService, never()).update(federate, federate); service.poll(); verify(populateStatusFederationService, never()).update(primary, primary); verify(populateStatusFederationService, never()).update(federate, federate); federate.setStatus(MetaStoreStatus.UNAVAILABLE); service.poll(); verify(populateStatusFederationService).update(federate, federate); primary.setStatus(MetaStoreStatus.UNAVAILABLE); service.poll(); verify(populateStatusFederationService).update(primary, primary); }
@Test public void pollNotifyOnStateChangeStatusChangedTwice() throws Exception { AbstractMetaStore primary = AbstractMetaStore.newPrimaryInstance("p", "uri"); AbstractMetaStore federate = AbstractMetaStore.newFederatedInstance("f", "uri"); primary.setStatus(MetaStoreStatus.AVAILABLE); federate.setStatus(MetaStoreStatus.AVAILABLE); List<AbstractMetaStore> metastores = Lists.newArrayList(primary, federate); when(populateStatusFederationService.getAll()).thenReturn(metastores); service.poll(); federate.setStatus(MetaStoreStatus.UNAVAILABLE); service.poll(); federate.setStatus(MetaStoreStatus.AVAILABLE); service.poll(); verify(populateStatusFederationService, times(2)).update(federate, federate); } |
### Question:
LowerCasePrefixNamingStrategy implements PrefixNamingStrategy { @Override public String apply(AbstractMetaStore federatedMetaStore) { return federatedMetaStore.getDatabasePrefix().toLowerCase(Locale.ROOT); } @Override String apply(AbstractMetaStore federatedMetaStore); }### Answer:
@Test public void apply() { LowerCasePrefixNamingStrategy namingStrategy = new LowerCasePrefixNamingStrategy(); String result = namingStrategy.apply(AbstractMetaStore.newFederatedInstance("Name", "")); assertThat(result, is("name_")); } |
### Question:
PrefixBasedDatabaseMappingService implements MappingEventListener { @Override public void onRegister(AbstractMetaStore metaStore) { synchronized (mappingsByPrefix) { if (mappingsByPrefix.containsKey(metaStore.getDatabasePrefix())) { throw new WaggleDanceException("MetaStore with prefix '" + metaStore.getDatabasePrefix() + "' already registered, remove old one first or update"); } if (isPrimaryMetaStoreRegistered(metaStore)) { throw new WaggleDanceException("Primary metastore already registered, remove old one first or update"); } add(metaStore); } } PrefixBasedDatabaseMappingService(
MetaStoreMappingFactory metaStoreMappingFactory,
List<AbstractMetaStore> initialMetastores,
QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer:
@Test public void onRegister() { AbstractMetaStore newMetastore = newFederatedInstance("newName", "abc"); MetaStoreMapping newMapping = mockNewMapping(true, "newname_"); when(metaStoreMappingFactory.newInstance(newMetastore)).thenReturn(newMapping); service.onRegister(newMetastore); List<DatabaseMapping> databaseMappings = service.getDatabaseMappings(); assertThat(databaseMappings.size(), is(3)); assertThat(ImmutableSet .of(databaseMappings.get(0).getDatabasePrefix(), databaseMappings.get(1).getDatabasePrefix(), databaseMappings.get(2).getDatabasePrefix()), is(ImmutableSet.of("", DB_PREFIX, "newname_"))); }
@Test(expected = WaggleDanceException.class) public void onRegisterPreviousMappingThrowsException() { AbstractMetaStore newMetastore = newFederatedInstance(METASTORE_NAME, "abc"); service.onRegister(newMetastore); } |
### Question:
PrefixBasedDatabaseMappingService implements MappingEventListener { @Override public void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore) { synchronized (mappingsByPrefix) { remove(oldMetaStore); add(newMetaStore); } } PrefixBasedDatabaseMappingService(
MetaStoreMappingFactory metaStoreMappingFactory,
List<AbstractMetaStore> initialMetastores,
QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer:
@Test public void onUpdate() throws NoSuchObjectException { AbstractMetaStore newMetastore = newFederatedInstance(METASTORE_NAME, "abc"); MetaStoreMapping newMapping = mockNewMapping(true, DB_PREFIX); Iface newClient = Mockito.mock(Iface.class); when(newMapping.getClient()).thenReturn(newClient); when(metaStoreMappingFactory.newInstance(newMetastore)).thenReturn(newMapping); when(metaStoreMappingFactory.prefixNameFor(federatedMetastore)).thenReturn(DB_PREFIX); service.onUpdate(federatedMetastore, newMetastore); List<DatabaseMapping> databaseMappings = service.getDatabaseMappings(); assertThat(databaseMappings.size(), is(2)); assertThat( ImmutableSet.of(databaseMappings.get(0).getDatabasePrefix(), databaseMappings.get(1).getDatabasePrefix()), is(ImmutableSet.of("", DB_PREFIX))); DatabaseMapping databaseMapping = service.databaseMapping(DB_PREFIX); assertThat(databaseMapping.getClient(), is(newClient)); } |
### Question:
PrefixBasedDatabaseMappingService implements MappingEventListener { @Override public List<DatabaseMapping> getDatabaseMappings() { Builder<DatabaseMapping> builder = ImmutableList.builder(); synchronized (mappingsByPrefix) { for (DatabaseMapping databaseMapping : mappingsByPrefix.values()) { if (includeInResults(databaseMapping)) { builder.add(databaseMapping); } } } return builder.build(); } PrefixBasedDatabaseMappingService(
MetaStoreMappingFactory metaStoreMappingFactory,
List<AbstractMetaStore> initialMetastores,
QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer:
@Test public void onInitOverridesDuplicates() { List<AbstractMetaStore> duplicates = Arrays .asList(primaryMetastore, federatedMetastore, primaryMetastore, federatedMetastore); service = new PrefixBasedDatabaseMappingService(metaStoreMappingFactory, duplicates, queryMapping); assertThat(service.getDatabaseMappings().size(), is(2)); }
@Test public void databaseMappings() { List<DatabaseMapping> databaseMappings = service.getDatabaseMappings(); assertThat(databaseMappings.size(), is(2)); assertThat( ImmutableSet.of(databaseMappings.get(0).getDatabasePrefix(), databaseMappings.get(1).getDatabasePrefix()), is(ImmutableSet.of("", DB_PREFIX))); } |
### Question:
PrefixBasedDatabaseMappingService implements MappingEventListener { @Override public void onUnregister(AbstractMetaStore metaStore) { synchronized (mappingsByPrefix) { remove(metaStore); } } PrefixBasedDatabaseMappingService(
MetaStoreMappingFactory metaStoreMappingFactory,
List<AbstractMetaStore> initialMetastores,
QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer:
@Test public void onUnregister() { when(metaStoreMappingFactory.prefixNameFor(federatedMetastore)).thenReturn(DB_PREFIX); service.onUnregister(newFederatedInstance(METASTORE_NAME, URI)); List<DatabaseMapping> databaseMappings = service.getDatabaseMappings(); assertThat(databaseMappings.size(), is(1)); assertThat(databaseMappings.get(0).getDatabasePrefix(), is("")); } |
### Question:
PrefixBasedDatabaseMappingService implements MappingEventListener { @Override public DatabaseMapping primaryDatabaseMapping() { if (primaryDatabaseMapping == null) { throw new NoPrimaryMetastoreException("Waggle Dance error no primary database mapping available"); } return primaryDatabaseMapping; } PrefixBasedDatabaseMappingService(
MetaStoreMappingFactory metaStoreMappingFactory,
List<AbstractMetaStore> initialMetastores,
QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer:
@Test public void primaryDatabaseMapping() { DatabaseMapping mapping = service.primaryDatabaseMapping(); assertThat(mapping.getClient(), is(primaryDatabaseClient)); }
@Test(expected = NoPrimaryMetastoreException.class) public void noPrimaryMappingThrowsException() { when(metaStoreMappingFactory.newInstance(federatedMetastore)).thenReturn(metaStoreMappingFederated); service = new PrefixBasedDatabaseMappingService(metaStoreMappingFactory, Collections.singletonList(federatedMetastore), queryMapping); service.primaryDatabaseMapping(); } |
### Question:
PrefixBasedDatabaseMappingService implements MappingEventListener { @Override public DatabaseMapping databaseMapping(@NotNull String databaseName) throws NoSuchObjectException { synchronized (mappingsByPrefix) { for (Entry<String, DatabaseMapping> entry : mappingsByPrefix.entrySet()) { String metastorePrefix = entry.getKey(); if (Strings.isNotBlank(metastorePrefix) && databaseName.startsWith(metastorePrefix)) { DatabaseMapping databaseMapping = entry.getValue(); LOG.debug("Database Name `{}` maps to metastore with prefix `{}`", databaseName, metastorePrefix); if (includeInResults(databaseMapping, databaseName)) { return databaseMapping; } } } } DatabaseMapping databaseMapping = mappingsByPrefix.get(EMPTY_PREFIX); if (databaseMapping != null) { LOG.debug("Database Name `{}` maps to metastore with EMPTY_PREFIX", databaseName); if (includeInResults(databaseMapping, databaseName)) { return databaseMapping; } } if (primaryDatabaseMapping != null) { if (includeInResults(primaryDatabaseMapping, databaseName)) { LOG.debug("Database Name `{}` maps to 'primary' metastore", databaseName); return primaryDatabaseMapping; } throw new NoSuchObjectException("Primary metastore does not have database " + databaseName); } LOG.debug("Database Name `{}` not mapped", databaseName); throw new NoPrimaryMetastoreException( "Waggle Dance error no database mapping available tried to map database '" + databaseName + "'"); } PrefixBasedDatabaseMappingService(
MetaStoreMappingFactory metaStoreMappingFactory,
List<AbstractMetaStore> initialMetastores,
QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer:
@Test public void databaseMapping() throws NoSuchObjectException { DatabaseMapping databaseMapping = service.databaseMapping(DB_PREFIX + "suffix"); assertThat(databaseMapping.getDatabasePrefix(), is(DB_PREFIX)); }
@Test public void databaseMappingMapsToEmptyPrefix() throws NoSuchObjectException { DatabaseMapping databaseMapping = service.databaseMapping("some_unknown_prefix_db"); assertThat(databaseMapping.getDatabasePrefix(), is("")); }
@Test public void databaseMappingDefaultsToPrimaryWhenNothingMatches() throws NoSuchObjectException { DatabaseMapping databaseMapping = service.databaseMapping("some_unknown_prefix_db"); assertThat(databaseMapping.getDatabasePrefix(), is("")); }
@Test(expected = NoSuchObjectException.class) public void databaseMappingDefaultsToPrimaryEvenWhenNothingMatchesAndUnavailable() throws NoSuchObjectException { Mockito.reset(metaStoreMappingPrimary); when(metaStoreMappingPrimary.isAvailable()).thenReturn(false); DatabaseMapping databaseMapping = service.databaseMapping("some_unknown_prefix_db"); assertThat(databaseMapping.getDatabasePrefix(), is("")); }
@Test(expected = NoPrimaryMetastoreException.class) public void noPrimaryThrowsExceptionForUnmappedDatabase() throws NoSuchObjectException { when(metaStoreMappingFactory.newInstance(federatedMetastore)).thenReturn(metaStoreMappingFederated); service = new PrefixBasedDatabaseMappingService(metaStoreMappingFactory, Collections.singletonList(federatedMetastore), queryMapping); service.databaseMapping("some_unknown_prefix_db"); }
@Test public void databaseBelongingToFederatedMetastoreMapsToItWithEmptyPrefix() throws NoSuchObjectException { String testDatabase = "testDatabase"; federatedMetastore.setMappedDatabases(Collections.singletonList("testName")); metaStoreMappingFederated = mockNewMapping(true, DB_PREFIX); when(metaStoreMappingFactory.newInstance(federatedMetastore)).thenReturn(metaStoreMappingFederated); when(metaStoreMappingFederated.transformInboundDatabaseName(DB_PREFIX + testDatabase)).thenReturn(testDatabase); service = new PrefixBasedDatabaseMappingService(metaStoreMappingFactory, Arrays.asList(primaryMetastore, federatedMetastore), queryMapping); DatabaseMapping mapping = service.databaseMapping(DB_PREFIX + testDatabase); assertThat(mapping.getDatabasePrefix(), is("")); } |
### Question:
PrefixBasedDatabaseMappingService implements MappingEventListener { @Override public void close() throws IOException { if (mappingsByPrefix != null) { for (MetaStoreMapping metaStoreMapping : mappingsByPrefix.values()) { metaStoreMapping.close(); } } } PrefixBasedDatabaseMappingService(
MetaStoreMappingFactory metaStoreMappingFactory,
List<AbstractMetaStore> initialMetastores,
QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer:
@Test public void close() throws IOException { service.close(); verify(metaStoreMappingPrimary).close(); verify(metaStoreMappingFederated).close(); } |
### Question:
AdvancedPropertyUtils extends PropertyUtils { @Override public Property getProperty(Class<?> type, String name) { if (name.indexOf('-') > -1) { name = CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, name); } return super.getProperty(type, name); } @Override Property getProperty(Class<?> type, String name); @Override void setAllowReadOnlyProperties(boolean allowReadOnlyProperties); }### Answer:
@Test public void regularPropertyName() throws Exception { Property property = propertyUtils.getProperty(TestBean.class, longPropertyName); assertThat(property, is(notNullValue())); assertThat(property.getName(), is(longPropertyName)); }
@Test public void lowerHyphenPropertyName() throws Exception { Property property = propertyUtils.getProperty(TestBean.class, "long-property-name"); assertThat(property, is(notNullValue())); assertThat(property.getName(), is(longPropertyName)); }
@Test(expected = YAMLException.class) public void illegalPropertyName() throws Exception { propertyUtils.getProperty(TestBean.class, "unknown"); } |
### Question:
NotifyingFederationService implements FederationService { @PreDestroy public void preDestroy() { List<? extends AbstractMetaStore> federatedMetaStores = getAll(); for (AbstractMetaStore federatedMetaStore : federatedMetaStores) { onUnregister(federatedMetaStore); } } @Autowired NotifyingFederationService(FederatedMetaStoreStorage federatedMetaStoreStorage); @PostConstruct void postConstruct(); @PreDestroy void preDestroy(); void subscribe(FederationEventListener listener); void unsubscribe(FederationEventListener listener); @Override void register(@NotNull @Valid AbstractMetaStore metaStore); @Override void update(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void unregister(@NotNull String name); @Override AbstractMetaStore get(@NotNull String name); @Override List<AbstractMetaStore> getAll(); }### Answer:
@Test public void preDestroy() { service.preDestroy(); verify(federationEventListener).onUnregister(newFederatedInstance(METASTORE_NAME, URI)); } |
### Question:
NotifyingFederationService implements FederationService { @Override public void register(@NotNull @Valid AbstractMetaStore metaStore) { checkNotNull(metaStore, "federatedMetaStore cannot be null"); boolean metastoreDoesNotExist = federatedMetaStoreStorage.get(metaStore.getName()) == null; checkIsTrue(metastoreDoesNotExist, "MetaStore '" + metaStore + "' is already registered"); LOG.debug("Registering new federation {}", metaStore); synchronized (federatedMetaStoreStorage) { federatedMetaStoreStorage.insert(metaStore); onRegister(metaStore); } LOG.debug("New federation {} has been registered successfully", metaStore); } @Autowired NotifyingFederationService(FederatedMetaStoreStorage federatedMetaStoreStorage); @PostConstruct void postConstruct(); @PreDestroy void preDestroy(); void subscribe(FederationEventListener listener); void unsubscribe(FederationEventListener listener); @Override void register(@NotNull @Valid AbstractMetaStore metaStore); @Override void update(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void unregister(@NotNull String name); @Override AbstractMetaStore get(@NotNull String name); @Override List<AbstractMetaStore> getAll(); }### Answer:
@Test public void register() { AbstractMetaStore federatedMetaStore = newFederatedInstance("new_name", URI); service.register(federatedMetaStore); verify(federatedMetaStoreStorage).insert(federatedMetaStore); verify(federationEventListener).onRegister(federatedMetaStore); }
@Test(expected = ValidationException.class) public void registerAnExistingDatabasePrefix() { AbstractMetaStore federatedMetaStore = newFederatedInstance(METASTORE_NAME, URI); service.register(federatedMetaStore); } |
### Question:
NotifyingFederationService implements FederationService { @Override public void update(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore) { checkNotNull(oldMetaStore, "old federatedMetaStore cannot be null"); checkNotNull(newMetaStore, "new federatedMetaStore cannot be null"); boolean metastoreExists = federatedMetaStoreStorage.get(oldMetaStore.getName()) != null; checkIsTrue(metastoreExists, "MetaStore '" + oldMetaStore + "' is not registered"); if (!oldMetaStore.getName().equals(newMetaStore.getName())) { boolean newNameDoesNotExist = federatedMetaStoreStorage.get(newMetaStore.getName()) == null; checkIsTrue(newNameDoesNotExist, "MetaStore '" + newMetaStore + "' is already registered"); } LOG.debug("Registering update of existing federation {} to {}", oldMetaStore, newMetaStore); synchronized (federatedMetaStoreStorage) { federatedMetaStoreStorage.update(oldMetaStore, newMetaStore); onUpdate(oldMetaStore, newMetaStore); } LOG.debug("Update of federation {} to {} has been registered successfully", oldMetaStore, newMetaStore); } @Autowired NotifyingFederationService(FederatedMetaStoreStorage federatedMetaStoreStorage); @PostConstruct void postConstruct(); @PreDestroy void preDestroy(); void subscribe(FederationEventListener listener); void unsubscribe(FederationEventListener listener); @Override void register(@NotNull @Valid AbstractMetaStore metaStore); @Override void update(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void unregister(@NotNull String name); @Override AbstractMetaStore get(@NotNull String name); @Override List<AbstractMetaStore> getAll(); }### Answer:
@Test(expected = ValidationException.class) public void updateAnNonRegisteredMetastoreFails() { AbstractMetaStore federatedMetaStore = newFederatedInstance(METASTORE_NAME + "new", URI); service.update(federatedMetaStore, federatedMetaStore); } |
### Question:
NotifyingFederationService implements FederationService { @Override public void unregister(@NotNull String name) { checkNotNull(name, "name cannot be null"); checkNotNull(federatedMetaStoreStorage.get(name), "MeataStore with name '" + name + "' is not registered"); LOG.debug("Unregistering federation with name {}", name); synchronized (federatedMetaStoreStorage) { AbstractMetaStore federatedMetaStore = federatedMetaStoreStorage.delete(name); onUnregister(federatedMetaStore); } LOG.debug("Federation with name {} is no longer available", name); } @Autowired NotifyingFederationService(FederatedMetaStoreStorage federatedMetaStoreStorage); @PostConstruct void postConstruct(); @PreDestroy void preDestroy(); void subscribe(FederationEventListener listener); void unsubscribe(FederationEventListener listener); @Override void register(@NotNull @Valid AbstractMetaStore metaStore); @Override void update(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void unregister(@NotNull String name); @Override AbstractMetaStore get(@NotNull String name); @Override List<AbstractMetaStore> getAll(); }### Answer:
@Test public void unregister() { service.unregister(METASTORE_NAME); verify(federatedMetaStoreStorage).delete(METASTORE_NAME); verify(federationEventListener).onUnregister(newFederatedInstance(METASTORE_NAME, URI)); }
@Test(expected = ValidationException.class) public void unregisterANonExistentMetastore() { String name = "new_name"; service.unregister(name); } |
### Question:
NotifyingFederationService implements FederationService { @Override public AbstractMetaStore get(@NotNull String name) { AbstractMetaStore federatedMetaStore = federatedMetaStoreStorage.get(name); return checkNotNull(federatedMetaStore, "No federation with name '" + name + "' found"); } @Autowired NotifyingFederationService(FederatedMetaStoreStorage federatedMetaStoreStorage); @PostConstruct void postConstruct(); @PreDestroy void preDestroy(); void subscribe(FederationEventListener listener); void unsubscribe(FederationEventListener listener); @Override void register(@NotNull @Valid AbstractMetaStore metaStore); @Override void update(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void unregister(@NotNull String name); @Override AbstractMetaStore get(@NotNull String name); @Override List<AbstractMetaStore> getAll(); }### Answer:
@Test public void get() { AbstractMetaStore federatedMetaStores = service.get(METASTORE_NAME); verify(federatedMetaStoreStorage).get(METASTORE_NAME); assertThat(federatedMetaStores.getName(), is(METASTORE_NAME)); } |
### Question:
NotifyingFederationService implements FederationService { @Override public List<AbstractMetaStore> getAll() { return federatedMetaStoreStorage.getAll(); } @Autowired NotifyingFederationService(FederatedMetaStoreStorage federatedMetaStoreStorage); @PostConstruct void postConstruct(); @PreDestroy void preDestroy(); void subscribe(FederationEventListener listener); void unsubscribe(FederationEventListener listener); @Override void register(@NotNull @Valid AbstractMetaStore metaStore); @Override void update(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void unregister(@NotNull String name); @Override AbstractMetaStore get(@NotNull String name); @Override List<AbstractMetaStore> getAll(); }### Answer:
@Test public void getAll() { List<AbstractMetaStore> federatedMetaStores = service.getAll(); verify(federatedMetaStoreStorage).getAll(); assertThat(federatedMetaStores.size(), is(1)); assertThat(federatedMetaStores.get(0).getName(), is(METASTORE_NAME)); } |
### Question:
NotifyingFederationService implements FederationService { public void unsubscribe(FederationEventListener listener) { listeners.remove(listener); } @Autowired NotifyingFederationService(FederatedMetaStoreStorage federatedMetaStoreStorage); @PostConstruct void postConstruct(); @PreDestroy void preDestroy(); void subscribe(FederationEventListener listener); void unsubscribe(FederationEventListener listener); @Override void register(@NotNull @Valid AbstractMetaStore metaStore); @Override void update(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void unregister(@NotNull String name); @Override AbstractMetaStore get(@NotNull String name); @Override List<AbstractMetaStore> getAll(); }### Answer:
@Test public void unsubscribe() { service.unsubscribe(federationEventListener); AbstractMetaStore federatedMetaStore = newFederatedInstance("new_name", URI); service.register(federatedMetaStore); verify(federatedMetaStoreStorage).insert(federatedMetaStore); verifyZeroInteractions(federationEventListener); } |
### Question:
SimpleFederationStatusService implements FederationStatusService { @Override public MetaStoreStatus checkStatus(AbstractMetaStore abstractMetaStore) { try (MetaStoreMapping mapping = metaStoreMappingFactory.newInstance(abstractMetaStore)) { if (!mapping.isAvailable()) { return MetaStoreStatus.UNAVAILABLE; } } catch (Exception e) { return MetaStoreStatus.UNAVAILABLE; } return MetaStoreStatus.AVAILABLE; } @Autowired SimpleFederationStatusService(MetaStoreMappingFactory metaStoreMappingFactory); @Override MetaStoreStatus checkStatus(AbstractMetaStore abstractMetaStore); }### Answer:
@Test public void checkStatusAvailable() throws Exception { when(mapping.isAvailable()).thenReturn(true); MetaStoreStatus status = service.checkStatus(metaStore); assertThat(status, is(MetaStoreStatus.AVAILABLE)); }
@Test public void checkStatusUnavailable() throws Exception { when(mapping.isAvailable()).thenReturn(false); MetaStoreStatus status = service.checkStatus(metaStore); assertThat(status, is(MetaStoreStatus.UNAVAILABLE)); }
@Test public void checkStatusUnavailableViaException() throws Exception { when(mapping.isAvailable()).thenThrow(new RuntimeException("oh no metastore down!")); MetaStoreStatus status = service.checkStatus(metaStore); assertThat(status, is(MetaStoreStatus.UNAVAILABLE)); } |
### Question:
YamlFederatedMetaStoreStorage implements FederatedMetaStoreStorage { @PostConstruct public void loadFederation() { LOG.info("Loading federations from {}", federationConfigLocation); Map<String, AbstractMetaStore> newFederationsMap = new LinkedHashMap<>(); Federations federations = yamlMarshaller.unmarshall(federationConfigLocation); if (federations != null && federations.getPrimaryMetaStore() != null) { primaryMetaStore = federations.getPrimaryMetaStore(); insert(primaryMetaStore, newFederationsMap); } if (federations != null && federations.getFederatedMetaStores() != null) { for (AbstractMetaStore federatedMetaStore : federations.getFederatedMetaStores()) { if (federatedMetaStore.getFederationType() == FederationType.PRIMARY) { throw new RuntimeException("Found 'PRIMARY' metastore that should be configured as 'FEDERATED'"); } insert(federatedMetaStore, newFederationsMap); } } synchronized (federationsMapLock) { federationsMap = newFederationsMap; } LOG.info("Loaded {} federations", federationsMap.size()); } @Autowired YamlFederatedMetaStoreStorage(
@Value("${federation-config}") String federationConfigLocation,
YamlStorageConfiguration configuration); YamlFederatedMetaStoreStorage(
String federationConfigLocation,
YamlMarshaller yamlSerializer,
boolean writeConfigOnShutdown); @PostConstruct void loadFederation(); @PreDestroy void saveFederation(); @Override void insert(AbstractMetaStore federatedMetaStore); @Override void update(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override AbstractMetaStore delete(String name); @Override List<AbstractMetaStore> getAll(); @Override AbstractMetaStore get(String name); }### Answer:
@Test(expected = IllegalArgumentException.class) public void loadFederationSamePrefix() throws Exception { File f = dataFolder.getFile("same-prefix.yml"); YamlFederatedMetaStoreStorage storage = new YamlFederatedMetaStoreStorage(f.toURI().toString(), configuration); storage.loadFederation(); }
@Test(expected = IllegalArgumentException.class) public void loadTwoEmptyPrefixes() throws Exception { File f = dataFolder.getFile("two-empty-prefixes.yml"); YamlFederatedMetaStoreStorage storage = new YamlFederatedMetaStoreStorage(f.toURI().toString(), configuration); storage.loadFederation(); }
@Test(expected = ConstraintViolationException.class) public void loadFederationInvalidFederation() throws Exception { File f = dataFolder.getFile("invalid-federation.yml"); YamlFederatedMetaStoreStorage storage = new YamlFederatedMetaStoreStorage(f.toURI().toString(), configuration); storage.loadFederation(); } |
### Question:
YamlFederatedMetaStoreStorage implements FederatedMetaStoreStorage { @Override public void update(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore) { validate(newMetaStore); synchronized (federationsMapLock) { LOG.debug("Updating federation {} to {}", oldMetaStore, newMetaStore); if (newMetaStore.getFederationType() == FederationType.PRIMARY) { primaryMetaStore = (PrimaryMetaStore) newMetaStore; } federationsMap.remove(oldMetaStore.getName()); federationsMap.put(newMetaStore.getName(), newMetaStore); } } @Autowired YamlFederatedMetaStoreStorage(
@Value("${federation-config}") String federationConfigLocation,
YamlStorageConfiguration configuration); YamlFederatedMetaStoreStorage(
String federationConfigLocation,
YamlMarshaller yamlSerializer,
boolean writeConfigOnShutdown); @PostConstruct void loadFederation(); @PreDestroy void saveFederation(); @Override void insert(AbstractMetaStore federatedMetaStore); @Override void update(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override AbstractMetaStore delete(String name); @Override List<AbstractMetaStore> getAll(); @Override AbstractMetaStore get(String name); }### Answer:
@Test public void update() throws Exception { YamlFederatedMetaStoreStorage storage = new YamlFederatedMetaStoreStorage("", configuration); PrimaryMetaStore primary = newPrimaryInstance("prefix1", "metastoreUri"); storage.insert(primary); assertThat(storage.getAll().size(), is(1)); storage.update(primary, newPrimaryInstance("prefix1", "metastoreUriUPDATED")); assertThat(storage.getAll().size(), is(1)); assertThat(storage.getAll().get(0).getRemoteMetaStoreUris(), is("metastoreUriUPDATED")); } |
### Question:
YamlFederatedMetaStoreStorage implements FederatedMetaStoreStorage { @Override public AbstractMetaStore delete(String name) { AbstractMetaStore federatedMetaStore; synchronized (federationsMapLock) { federatedMetaStore = federationsMap.remove(name); if (federatedMetaStore != null && federatedMetaStore.getFederationType() == FederationType.PRIMARY) { primaryMetaStore = null; } } return federatedMetaStore; } @Autowired YamlFederatedMetaStoreStorage(
@Value("${federation-config}") String federationConfigLocation,
YamlStorageConfiguration configuration); YamlFederatedMetaStoreStorage(
String federationConfigLocation,
YamlMarshaller yamlSerializer,
boolean writeConfigOnShutdown); @PostConstruct void loadFederation(); @PreDestroy void saveFederation(); @Override void insert(AbstractMetaStore federatedMetaStore); @Override void update(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override AbstractMetaStore delete(String name); @Override List<AbstractMetaStore> getAll(); @Override AbstractMetaStore get(String name); }### Answer:
@Test public void delete() throws Exception { YamlFederatedMetaStoreStorage storage = new YamlFederatedMetaStoreStorage("", configuration); PrimaryMetaStore metaStore = newPrimaryInstance("name1", "metastoreUri"); storage.insert(metaStore); assertThat(storage.getAll().size(), is(1)); storage.delete(metaStore.getName()); assertThat(storage.getAll().size(), is(0)); } |
### Question:
YamlFederatedMetaStoreStorage implements FederatedMetaStoreStorage { private static void insert(AbstractMetaStore federatedMetaStore, Map<String, AbstractMetaStore> federationsMap) { validate(federatedMetaStore); if (federationsMap.containsKey(federatedMetaStore.getName())) { throw new IllegalArgumentException("Name '" + federatedMetaStore.getName() + "' is already registered"); } if (!uniqueMetaStorePrefix(federatedMetaStore.getDatabasePrefix(), federationsMap)) { throw new IllegalArgumentException( "Prefix '" + federatedMetaStore.getDatabasePrefix() + "' is already registered"); } LOG.info("Adding federation {}", federatedMetaStore); federationsMap.put(federatedMetaStore.getName(), federatedMetaStore); } @Autowired YamlFederatedMetaStoreStorage(
@Value("${federation-config}") String federationConfigLocation,
YamlStorageConfiguration configuration); YamlFederatedMetaStoreStorage(
String federationConfigLocation,
YamlMarshaller yamlSerializer,
boolean writeConfigOnShutdown); @PostConstruct void loadFederation(); @PreDestroy void saveFederation(); @Override void insert(AbstractMetaStore federatedMetaStore); @Override void update(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override AbstractMetaStore delete(String name); @Override List<AbstractMetaStore> getAll(); @Override AbstractMetaStore get(String name); }### Answer:
@Test(expected = IllegalArgumentException.class) public void insertWithSameNameFails() throws Exception { YamlFederatedMetaStoreStorage storage = new YamlFederatedMetaStoreStorage("", configuration); PrimaryMetaStore primary = newPrimaryInstance("primary", "metastoreUri"); storage.insert(primary); FederatedMetaStore federatedWithSameName = AbstractMetaStore.newFederatedInstance(primary.getName(), "uris"); storage.insert(federatedWithSameName); }
@Test(expected = IllegalArgumentException.class) public void insertPrimaryWithSamePrefixFails() throws Exception { YamlFederatedMetaStoreStorage storage = new YamlFederatedMetaStoreStorage("", configuration); PrimaryMetaStore primary = newPrimaryInstance("primary", "metastoreUri"); storage.insert(primary); PrimaryMetaStore primaryWithSamePrefix = newPrimaryInstance("newPrimary", "uris"); storage.insert(primaryWithSamePrefix); }
@Test(expected = IllegalArgumentException.class) public void insertFederatedWithSamePrefixFails() throws Exception { YamlFederatedMetaStoreStorage storage = new YamlFederatedMetaStoreStorage("", configuration); FederatedMetaStore metaStore = newFederatedInstance("name", "metastoreUri"); storage.insert(metaStore); FederatedMetaStore metaStoreWithSamePrefix = newFederatedInstance("newName", "uris"); metaStoreWithSamePrefix.setDatabasePrefix(metaStore.getDatabasePrefix()); storage.insert(metaStoreWithSamePrefix); } |
### Question:
MonitoredDatabaseMappingService implements MappingEventListener { @Override public DatabaseMapping primaryDatabaseMapping() { DatabaseMapping primaryDatabaseMapping = wrapped.primaryDatabaseMapping(); CurrentMonitoredMetaStoreHolder.monitorMetastore(primaryDatabaseMapping.getMetastoreMappingName()); return primaryDatabaseMapping; } MonitoredDatabaseMappingService(MappingEventListener wrapped); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override List<DatabaseMapping> getDatabaseMappings(); @Override void close(); @Override void onRegister(AbstractMetaStore federatedMetaStore); @Override void onUnregister(AbstractMetaStore federatedMetaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); }### Answer:
@Test public void primaryDatabaseMapping() { assertThat(service.primaryDatabaseMapping(), is(primaryMapping)); verify(wrapped).primaryDatabaseMapping(); assertThat(CurrentMonitoredMetaStoreHolder.getMonitorMetastore(), is("primary")); } |
### Question:
MonitoredDatabaseMappingService implements MappingEventListener { @Override public DatabaseMapping databaseMapping(@NotNull String databaseName) throws NoSuchObjectException { DatabaseMapping databaseMapping = wrapped.databaseMapping(databaseName); CurrentMonitoredMetaStoreHolder.monitorMetastore(databaseMapping.getMetastoreMappingName()); return databaseMapping; } MonitoredDatabaseMappingService(MappingEventListener wrapped); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override List<DatabaseMapping> getDatabaseMappings(); @Override void close(); @Override void onRegister(AbstractMetaStore federatedMetaStore); @Override void onUnregister(AbstractMetaStore federatedMetaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); }### Answer:
@Test public void databaseMapping() throws NoSuchObjectException { assertThat(service.databaseMapping("other"), is(otherMapping)); verify(wrapped).databaseMapping("other"); assertThat(CurrentMonitoredMetaStoreHolder.getMonitorMetastore(), is("other")); } |
### Question:
AdvancedPropertyUtils extends PropertyUtils { @Override protected Set<Property> createPropertySet(Class<?> type, BeanAccess beanAccess) { Set<Property> properties = new TreeSet<>(); Collection<Property> props = getPropertiesMap(type, beanAccess).values(); for (Property property : props) { if (include(property)) { properties.add(property); } } return properties; } @Override Property getProperty(Class<?> type, String name); @Override void setAllowReadOnlyProperties(boolean allowReadOnlyProperties); }### Answer:
@Test public void createPropertySetWithDefaultBeanAccess() throws Exception { Set<Property> properties = propertyUtils.createPropertySet(TestBean.class, BeanAccess.DEFAULT); assertThat(properties.size(), is(1)); assertThat(properties.iterator().next().getName(), is(longPropertyName)); }
@Test public void createPropertySetWithFieldBeanAccess() throws Exception { Set<Property> properties = propertyUtils.createPropertySet(TestBean.class, BeanAccess.FIELD); assertThat(properties.size(), is(2)); Iterator<Property> iterator = properties.iterator(); assertThat(iterator.next().getName(), is(longPropertyName)); assertThat(iterator.next().getName(), is("transientProperty")); }
@Test public void createPropertySetWithPropertyBeanAccess() throws Exception { Set<Property> properties = propertyUtils.createPropertySet(TestBean.class, BeanAccess.PROPERTY); assertThat(properties.size(), is(1)); assertThat(properties.iterator().next().getName(), is(longPropertyName)); }
@Test public void createUnwriteablePropertySet() throws IntrospectionException, NoSuchFieldException, SecurityException { Set<Property> properties = propertyUtils.createPropertySet(UnwriteableTestBean.class, BeanAccess.DEFAULT); assertThat(properties.size(), is(0)); }
@Test public void createUnreadablePropertySet() throws NoSuchFieldException, SecurityException, IntrospectionException { Set<Property> properties = propertyUtils.createPropertySet(UnreadableTestBean.class, BeanAccess.DEFAULT); assertThat(properties.size(), is(0)); } |
### Question:
MonitoredDatabaseMappingService implements MappingEventListener { @Override public PanopticOperationHandler getPanopticOperationHandler() { PanopticOperationHandler handler = wrapped.getPanopticOperationHandler(); CurrentMonitoredMetaStoreHolder.monitorMetastore(); return handler; } MonitoredDatabaseMappingService(MappingEventListener wrapped); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override List<DatabaseMapping> getDatabaseMappings(); @Override void close(); @Override void onRegister(AbstractMetaStore federatedMetaStore); @Override void onUnregister(AbstractMetaStore federatedMetaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); }### Answer:
@Test public void getMultiMetaStoreOperationsHandler() { assertThat(service.getPanopticOperationHandler(), is(multiMetastoreOperationsHandler)); verify(wrapped).getPanopticOperationHandler(); assertThat(CurrentMonitoredMetaStoreHolder.getMonitorMetastore(), is("all")); } |
### Question:
MonitoredDatabaseMappingService implements MappingEventListener { @Override public void onRegister(AbstractMetaStore federatedMetaStore) { wrapped.onRegister(federatedMetaStore); } MonitoredDatabaseMappingService(MappingEventListener wrapped); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override List<DatabaseMapping> getDatabaseMappings(); @Override void close(); @Override void onRegister(AbstractMetaStore federatedMetaStore); @Override void onUnregister(AbstractMetaStore federatedMetaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); }### Answer:
@Test public void onRegister() throws Exception { service.onRegister(metaStore); verify(wrapped).onRegister(metaStore); } |
### Question:
MonitoredDatabaseMappingService implements MappingEventListener { @Override public void onUnregister(AbstractMetaStore federatedMetaStore) { wrapped.onUnregister(federatedMetaStore); } MonitoredDatabaseMappingService(MappingEventListener wrapped); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override List<DatabaseMapping> getDatabaseMappings(); @Override void close(); @Override void onRegister(AbstractMetaStore federatedMetaStore); @Override void onUnregister(AbstractMetaStore federatedMetaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); }### Answer:
@Test public void onUnregister() throws Exception { service.onUnregister(metaStore); verify(wrapped).onUnregister(metaStore); } |
### Question:
MonitoredDatabaseMappingService implements MappingEventListener { @Override public void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore) { wrapped.onUpdate(oldMetaStore, newMetaStore); } MonitoredDatabaseMappingService(MappingEventListener wrapped); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override List<DatabaseMapping> getDatabaseMappings(); @Override void close(); @Override void onRegister(AbstractMetaStore federatedMetaStore); @Override void onUnregister(AbstractMetaStore federatedMetaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); }### Answer:
@Test public void onUpdate() throws Exception { AbstractMetaStore newMetastore = Mockito.mock(AbstractMetaStore.class); service.onUpdate(metaStore, newMetastore); verify(wrapped).onUpdate(metaStore, newMetastore); } |
### Question:
MonitoredDatabaseMappingService implements MappingEventListener { @Override public void close() throws IOException { wrapped.close(); } MonitoredDatabaseMappingService(MappingEventListener wrapped); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override List<DatabaseMapping> getDatabaseMappings(); @Override void close(); @Override void onRegister(AbstractMetaStore federatedMetaStore); @Override void onUnregister(AbstractMetaStore federatedMetaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); }### Answer:
@Test public void close() throws Exception { service.close(); verify(wrapped).close(); } |
### Question:
MonitoredDatabaseMappingService implements MappingEventListener { @Override public List<DatabaseMapping> getDatabaseMappings() { return wrapped.getDatabaseMappings(); } MonitoredDatabaseMappingService(MappingEventListener wrapped); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override List<DatabaseMapping> getDatabaseMappings(); @Override void close(); @Override void onRegister(AbstractMetaStore federatedMetaStore); @Override void onUnregister(AbstractMetaStore federatedMetaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); }### Answer:
@Test public void getDatabaseMappings() { List<DatabaseMapping> databaseMappings = Arrays.asList(primaryMapping, otherMapping); when(wrapped.getDatabaseMappings()).thenReturn(databaseMappings); assertThat(service.getDatabaseMappings(), is(databaseMappings)); } |
### Question:
GetAllFunctionsRequest implements RequestCallable<List<GetAllFunctionsResponse>> { @Override public List<GetAllFunctionsResponse> call() throws Exception { GetAllFunctionsResponse response = mapping.getClient().get_all_functions(); if (response.getFunctions() != null) { for (Function function : response.getFunctions()) { mapping.transformOutboundFunction(function); } } return Collections.singletonList(response); } GetAllFunctionsRequest(DatabaseMapping mapping); @Override List<GetAllFunctionsResponse> call(); @Override DatabaseMapping getMapping(); }### Answer:
@Test public void call() throws Exception { GetAllFunctionsRequest request = new GetAllFunctionsRequest(mapping); GetAllFunctionsResponse response = new GetAllFunctionsResponse(); Function function = newFunction("db", "fn1"); response.addToFunctions(function); when(mapping.getClient()).thenReturn(client); when(mapping.getClient().get_all_functions()).thenReturn(response); List<GetAllFunctionsResponse> responses = request.call(); assertThat(responses.size(), is(1)); assertThat(responses.get(0), is(response)); verify(mapping).transformOutboundFunction(function); }
@Test public void callFunctionsNotSet() throws Exception { GetAllFunctionsRequest request = new GetAllFunctionsRequest(mapping); GetAllFunctionsResponse response = new GetAllFunctionsResponse(); when(mapping.getClient()).thenReturn(client); when(mapping.getClient().get_all_functions()).thenReturn(response); List<GetAllFunctionsResponse> responses = request.call(); assertThat(responses.size(), is(1)); assertThat(responses.get(0), is(response)); verify(mapping, never()).transformOutboundFunction(any(Function.class)); }
@Test public void callFunctionsEmpty() throws Exception { GetAllFunctionsRequest request = new GetAllFunctionsRequest(mapping); GetAllFunctionsResponse response = new GetAllFunctionsResponse(); response.setFunctions(Collections.emptyList()); when(mapping.getClient()).thenReturn(client); when(mapping.getClient().get_all_functions()).thenReturn(response); List<GetAllFunctionsResponse> responses = request.call(); assertThat(responses.size(), is(1)); assertThat(responses.get(0), is(response)); verify(mapping, never()).transformOutboundFunction(any(Function.class)); } |
### Question:
GetAllFunctionsRequest implements RequestCallable<List<GetAllFunctionsResponse>> { @Override public DatabaseMapping getMapping() { return mapping; } GetAllFunctionsRequest(DatabaseMapping mapping); @Override List<GetAllFunctionsResponse> call(); @Override DatabaseMapping getMapping(); }### Answer:
@Test public void getMapping() throws Exception { GetAllFunctionsRequest request = new GetAllFunctionsRequest(mapping); assertThat(request.getMapping(), is(mapping)); } |
### Question:
TTransportMonitor { public void monitor(@WillClose TTransport transport, @WillClose Closeable action) { transports.offer(new ActionContainer(transport, action)); } @Autowired TTransportMonitor(WaggleDanceConfiguration waggleDanceConfiguration); @VisibleForTesting TTransportMonitor(WaggleDanceConfiguration waggleDanceConfiguration, ScheduledExecutorService scheduler); @PreDestroy void shutdown(); void monitor(@WillClose TTransport transport, @WillClose Closeable action); }### Answer:
@Test public void shouldNotDisconnect() throws Exception { when(transport.peek()).thenReturn(true); monitor.monitor(transport, action); runnableCaptor.getValue().run(); verify(transport, never()).close(); verify(action, never()).close(); }
@Test public void shouldDisconnect() throws Exception { when(transport.peek()).thenReturn(false); monitor.monitor(transport, action); runnableCaptor.getValue().run(); verify(transport).close(); verify(action).close(); }
@Test public void shouldDisconnectWhenTransportThrowsException() throws Exception { when(transport.peek()).thenReturn(false); doThrow(new RuntimeException()).when(transport).close(); monitor.monitor(transport, action); runnableCaptor.getValue().run(); verify(transport).close(); verify(action).close(); }
@Test public void shouldDisconnectWhenActionThrowsException() throws Exception { when(transport.peek()).thenReturn(false); doThrow(new RuntimeException()).when(action).close(); monitor.monitor(transport, action); runnableCaptor.getValue().run(); verify(transport).close(); verify(action).close(); } |
### Question:
ReadWriteCreateAccessControlHandler implements AccessControlHandler { @Override public boolean hasWritePermission(String databaseName) { return true; } ReadWriteCreateAccessControlHandler(AbstractMetaStore metaStore,
FederationService federationService); @Override boolean hasWritePermission(String databaseName); @Override boolean hasCreatePermission(); @Override void databaseCreatedNotification(String name); }### Answer:
@Test public void hasWritePermission() { assertTrue(handler.hasWritePermission("db")); assertTrue(handler.hasWritePermission(null)); } |
### Question:
ReadWriteCreateAccessControlHandler implements AccessControlHandler { @Override public boolean hasCreatePermission() { return true; } ReadWriteCreateAccessControlHandler(AbstractMetaStore metaStore,
FederationService federationService); @Override boolean hasWritePermission(String databaseName); @Override boolean hasCreatePermission(); @Override void databaseCreatedNotification(String name); }### Answer:
@Test public void hasCreatePermission() { assertTrue(handler.hasCreatePermission()); } |
### Question:
ReadWriteCreateAccessControlHandler implements AccessControlHandler { @Override public void databaseCreatedNotification(String name) { List<String> mappedDatabases = null; if (metaStore.getMappedDatabases() != null) { mappedDatabases = new ArrayList<>(metaStore.getMappedDatabases()); if (!mappedDatabases.contains(name)) { mappedDatabases.add(name); } } AbstractMetaStore newMetaStore; if (metaStore instanceof PrimaryMetaStore) { newMetaStore = new PrimaryMetaStore(metaStore.getName(), metaStore.getRemoteMetaStoreUris(), metaStore.getAccessControlType()); newMetaStore.setMappedDatabases(mappedDatabases); } else { throw new WaggleDanceException( String.format("Metastore type %s does not support database creation", metaStore.getClass().getName())); } federationService.update(metaStore, newMetaStore); metaStore = newMetaStore; } ReadWriteCreateAccessControlHandler(AbstractMetaStore metaStore,
FederationService federationService); @Override boolean hasWritePermission(String databaseName); @Override boolean hasCreatePermission(); @Override void databaseCreatedNotification(String name); }### Answer:
@Test public void databaseCreatedNotificationPrimaryNoMapped() { handler.databaseCreatedNotification(database); verify(federationService).update(eq(primaryMetaStore), captor.capture()); PrimaryMetaStore newPrimaryMetaStore = captor.getValue(); assertThat(newPrimaryMetaStore.getMappedDatabases().size(), is(1)); assertThat(newPrimaryMetaStore.getMappedDatabases().get(0), is(database)); }
@Test public void databaseCreatedNotificationPrimaryHasEmptyMapped() { when(primaryMetaStore.getMappedDatabases()).thenReturn(Collections.emptyList()); handler.databaseCreatedNotification(database); verify(federationService).update(eq(primaryMetaStore), captor.capture()); PrimaryMetaStore newPrimaryMetaStore = captor.getValue(); assertThat(newPrimaryMetaStore.getMappedDatabases().size(), is(1)); assertThat(newPrimaryMetaStore.getMappedDatabases().get(0), is(database)); }
@Test public void databaseCreatedNotificationPrimaryHasNonEmptyMapped() { List<String> mappedDatabases = Arrays.asList("db1", "db2", "db3"); when(primaryMetaStore.getMappedDatabases()).thenReturn(mappedDatabases); handler.databaseCreatedNotification(database); verify(federationService).update(eq(primaryMetaStore), captor.capture()); PrimaryMetaStore newPrimaryMetaStore = captor.getValue(); assertThat(newPrimaryMetaStore.getMappedDatabases().size(), is(mappedDatabases.size() + 1)); assertThat(newPrimaryMetaStore.getMappedDatabases().get(mappedDatabases.size()), is(database)); } |
### Question:
ReadOnlyAccessControlHandler implements AccessControlHandler { @Override public boolean hasWritePermission(String databaseName) { return false; } @Override boolean hasWritePermission(String databaseName); @Override boolean hasCreatePermission(); @Override void databaseCreatedNotification(String name); }### Answer:
@Test public void hasWritePermission() { ReadOnlyAccessControlHandler handler = new ReadOnlyAccessControlHandler(); assertFalse(handler.hasWritePermission("db")); assertFalse(handler.hasWritePermission(null)); } |
### Question:
ReadOnlyAccessControlHandler implements AccessControlHandler { @Override public boolean hasCreatePermission() { return false; } @Override boolean hasWritePermission(String databaseName); @Override boolean hasCreatePermission(); @Override void databaseCreatedNotification(String name); }### Answer:
@Test public void hasCreatePermission() { ReadOnlyAccessControlHandler handler = new ReadOnlyAccessControlHandler(); assertFalse(handler.hasCreatePermission()); } |
### Question:
ReadOnlyAccessControlHandler implements AccessControlHandler { @Override public void databaseCreatedNotification(String name) { } @Override boolean hasWritePermission(String databaseName); @Override boolean hasCreatePermission(); @Override void databaseCreatedNotification(String name); }### Answer:
@Test public void databaseCreatedNotification() { ReadOnlyAccessControlHandler handler = new ReadOnlyAccessControlHandler(); handler.databaseCreatedNotification("db"); } |
### Question:
AccessControlHandlerFactory { public AccessControlHandler newInstance(AbstractMetaStore metaStore) { switch (metaStore.getAccessControlType()) { case READ_ONLY: return new ReadOnlyAccessControlHandler(); case READ_AND_WRITE_ON_DATABASE_WHITELIST: return new DatabaseWhitelistAccessControlHandler(metaStore, federationService, CANNOT_CREATE); case READ_AND_WRITE_AND_CREATE: if (metaStore.getFederationType() == FederationType.PRIMARY) { return new ReadWriteCreateAccessControlHandler(metaStore, federationService); } else { throw new IllegalStateException("Write access on anything other then a 'primary' metastore is not allowed"); } case READ_AND_WRITE_AND_CREATE_ON_DATABASE_WHITELIST: if (metaStore.getFederationType() == FederationType.PRIMARY) { return new DatabaseWhitelistAccessControlHandler(metaStore, federationService, CAN_CREATE); } else { throw new IllegalStateException("Write access on anything other then a 'primary' metastore is not allowed"); } default: throw new IllegalStateException("Cannot determine AcccessControlHandler type given type: '" + metaStore.getAccessControlType() + "'"); } } @Autowired AccessControlHandlerFactory(@Qualifier("notifyingFederationService") FederationService federationService); AccessControlHandler newInstance(AbstractMetaStore metaStore); }### Answer:
@Test public void newInstanceReadOnly() throws Exception { FederatedMetaStore federatedMetaStore = new FederatedMetaStore(); federatedMetaStore.setAccessControlType(AccessControlType.READ_ONLY); AccessControlHandler newInstance = factory.newInstance(federatedMetaStore); assertTrue(newInstance instanceof ReadOnlyAccessControlHandler); }
@Test public void newInstanceReadAndWriteOnDatabaseWhiteList() throws Exception { PrimaryMetaStore primaryMetaStore = new PrimaryMetaStore("primary", "", AccessControlType.READ_AND_WRITE_ON_DATABASE_WHITELIST); AccessControlHandler newInstance = factory.newInstance(primaryMetaStore); assertTrue(newInstance instanceof DatabaseWhitelistAccessControlHandler); assertFalse(newInstance.hasCreatePermission()); }
@Test public void newInstanceReadAndWriteAndCreate() throws Exception { PrimaryMetaStore primaryMetaStore = new PrimaryMetaStore("primary", "", AccessControlType.READ_AND_WRITE_AND_CREATE); AccessControlHandler newInstance = factory.newInstance(primaryMetaStore); assertTrue(newInstance instanceof ReadWriteCreateAccessControlHandler); assertTrue(newInstance.hasCreatePermission()); }
@Test(expected = IllegalStateException.class) public void newInstanceReadAndWriteAndCreateNotPrimary() { FederatedMetaStore federatedMetaStore = new FederatedMetaStore("federated", "", AccessControlType.READ_AND_WRITE_AND_CREATE); factory.newInstance(federatedMetaStore); }
@Test public void newInstanceReadAndWriteAndCreateOnDatabaseWhiteList() throws Exception { PrimaryMetaStore primaryMetaStore = new PrimaryMetaStore("primary", "", AccessControlType.READ_AND_WRITE_AND_CREATE_ON_DATABASE_WHITELIST); AccessControlHandler newInstance = factory.newInstance(primaryMetaStore); assertTrue(newInstance instanceof DatabaseWhitelistAccessControlHandler); assertTrue(newInstance.hasCreatePermission()); }
@Test(expected = IllegalStateException.class) public void newInstanceReadAndWriteAndCreateOnDatabaseWhiteListNotPrimary() { FederatedMetaStore federatedMetaStore = new FederatedMetaStore("federated", "", AccessControlType.READ_AND_WRITE_AND_CREATE_ON_DATABASE_WHITELIST); factory.newInstance(federatedMetaStore); } |
### Question:
DatabaseWhitelistAccessControlHandler implements AccessControlHandler { @Override public boolean hasWritePermission(String databaseName) { return writableDatabaseWhiteList.contains(databaseName); } DatabaseWhitelistAccessControlHandler(
AbstractMetaStore metaStore,
FederationService federationService,
boolean hasCreatePermission); @Override boolean hasWritePermission(String databaseName); @Override boolean hasCreatePermission(); @Override void databaseCreatedNotification(String name); }### Answer:
@Test public void hasWritePermission() throws Exception { assertTrue(handler.hasWritePermission("writableDB")); assertTrue(handler.hasWritePermission(null)); assertFalse(handler.hasWritePermission("nonWritableDB")); }
@Test public void hasRegexGrantedWritePermission() throws Exception { assertTrue(handler.hasWritePermission("userDB1")); assertTrue(handler.hasWritePermission("userdb2")); assertFalse(handler.hasWritePermission("user")); } |
### Question:
DatabaseWhitelistAccessControlHandler implements AccessControlHandler { @Override public boolean hasCreatePermission() { return hasCreatePermission; } DatabaseWhitelistAccessControlHandler(
AbstractMetaStore metaStore,
FederationService federationService,
boolean hasCreatePermission); @Override boolean hasWritePermission(String databaseName); @Override boolean hasCreatePermission(); @Override void databaseCreatedNotification(String name); }### Answer:
@Test public void hasCreatePermission() throws Exception { assertTrue(handler.hasCreatePermission()); assertTrue(handler.hasWritePermission(null)); assertTrue(handler.hasCreatePermission()); } |
### Question:
DatabaseWhitelistAccessControlHandler implements AccessControlHandler { @Override public void databaseCreatedNotification(String name) { List<String> newWritableDatabaseWhiteList = new ArrayList<>(metaStore.getWritableDatabaseWhiteList()); List<String> mappedDatabases = null; String nameLowerCase = trimToLowerCase(name); if (!newWritableDatabaseWhiteList.contains(nameLowerCase)) { newWritableDatabaseWhiteList.add(nameLowerCase); } if (metaStore.getMappedDatabases() != null) { mappedDatabases = new ArrayList<>(metaStore.getMappedDatabases()); if (!mappedDatabases.contains(name)) { mappedDatabases.add(name); } } AbstractMetaStore newMetaStore; if (metaStore instanceof PrimaryMetaStore) { newMetaStore = new PrimaryMetaStore(metaStore.getName(), metaStore.getRemoteMetaStoreUris(), metaStore.getAccessControlType(), newWritableDatabaseWhiteList); newMetaStore.setMappedDatabases(mappedDatabases); } else { throw new WaggleDanceException( String.format("Metastore type %s does not support database creation", metaStore.getClass().getName())); } federationService.update(metaStore, newMetaStore); metaStore = newMetaStore; writableDatabaseWhiteList.add(nameLowerCase); } DatabaseWhitelistAccessControlHandler(
AbstractMetaStore metaStore,
FederationService federationService,
boolean hasCreatePermission); @Override boolean hasWritePermission(String databaseName); @Override boolean hasCreatePermission(); @Override void databaseCreatedNotification(String name); }### Answer:
@Test public void databaseCreatedNotification() throws Exception { handler.databaseCreatedNotification("newDB"); verify(federationService).update(eq(primaryMetaStore), captor.capture()); PrimaryMetaStore updatedMetastore = captor.getValue(); assertThat(updatedMetastore.getWritableDatabaseWhiteList().size(), is(3)); assertThat(updatedMetastore.getWritableDatabaseWhiteList(), contains("writabledb", "userdb.*", "newdb")); }
@Test public void databaseCreatedNotificationNoDuplicates() throws Exception { handler.databaseCreatedNotification("writabledb"); verify(federationService).update(eq(primaryMetaStore), captor.capture()); PrimaryMetaStore updatedMetastore = captor.getValue(); assertThat(updatedMetastore.getWritableDatabaseWhiteList().size(), is(2)); assertThat(updatedMetastore.getWritableDatabaseWhiteList(), contains("writabledb", "userdb.*")); }
@Test public void databaseCreatedNotificationPrimaryNoMapped() { String database = "database"; handler.databaseCreatedNotification(database); verify(federationService).update(eq(primaryMetaStore), captor.capture()); PrimaryMetaStore newPrimaryMetaStore = captor.getValue(); assertThat(newPrimaryMetaStore.getMappedDatabases().size(), is(1)); assertThat(newPrimaryMetaStore.getMappedDatabases().get(0), is(database)); }
@Test public void databaseCreatedNotificationPrimaryHasEmptyMapped() { String database = "database"; when(primaryMetaStore.getMappedDatabases()).thenReturn(Collections.emptyList()); handler.databaseCreatedNotification(database); verify(federationService).update(eq(primaryMetaStore), captor.capture()); PrimaryMetaStore newPrimaryMetaStore = captor.getValue(); assertThat(newPrimaryMetaStore.getMappedDatabases().size(), is(1)); assertThat(newPrimaryMetaStore.getMappedDatabases().get(0), is(database)); }
@Test public void databaseCreatedNotificationPrimaryHasNonEmptyMapped() { String database = "database"; List<String> mappedDatabases = Arrays.asList("db1", "db2", "db3"); when(primaryMetaStore.getMappedDatabases()).thenReturn(mappedDatabases); handler.databaseCreatedNotification(database); verify(federationService).update(eq(primaryMetaStore), captor.capture()); PrimaryMetaStore newPrimaryMetaStore = captor.getValue(); assertThat(newPrimaryMetaStore.getMappedDatabases().size(), is(mappedDatabases.size() + 1)); assertThat(newPrimaryMetaStore.getMappedDatabases().get(mappedDatabases.size()), is(database)); } |
### Question:
Whitelist { public void add(String databaseName) { whiteList.add(Pattern.compile(trimToLowerCase(databaseName))); } Whitelist(); Whitelist(List<String> writableDatabaseWhiteList); void add(String databaseName); boolean contains(String databaseName); }### Answer:
@Test public void add() { Whitelist whitelist = new Whitelist(); whitelist.add("db"); assertThat(whitelist.size(), is(1)); } |
### Question:
Whitelist { public boolean contains(String databaseName) { if (databaseName == null) { return true; } databaseName = trimToLowerCase(databaseName); for (Pattern whiteListEntry : whiteList) { Matcher matcher = whiteListEntry.matcher(databaseName); if (matcher.matches()) { return true; } } return false; } Whitelist(); Whitelist(List<String> writableDatabaseWhiteList); void add(String databaseName); boolean contains(String databaseName); }### Answer:
@Test public void containsTrue() { Whitelist whitelist = new Whitelist(ImmutableList.of("db_.*", "user")); assertTrue(whitelist.contains("db_test")); assertTrue(whitelist.contains("user")); }
@Test public void containsFalse() { Whitelist whitelist = new Whitelist(ImmutableList.of("db_.*", "user")); assertFalse(whitelist.contains("foo")); assertFalse(whitelist.contains("users")); } |
### Question:
CommonBeans { @Bean public HiveConf hiveConf(WaggleDanceConfiguration waggleDanceConfiguration) { Map<String, String> confProps = waggleDanceConfiguration.getConfigurationProperties(); final HiveConf hiveConf = new HiveConf(new Configuration(false), getClass()); if (confProps != null) { for (Map.Entry<String, String> entry : confProps.entrySet()) { hiveConf.set(entry.getKey(), entry.getValue()); } } return hiveConf; } @Bean HiveConf hiveConf(WaggleDanceConfiguration waggleDanceConfiguration); @Bean PrefixNamingStrategy prefixNamingStrategy(WaggleDanceConfiguration waggleDanceConfiguration); @Bean CloseableThriftHiveMetastoreIfaceClientFactory metaStoreClientFactory(); @Bean QueryMapping queryMapping(); @Bean PollingFederationService pollingFederationService(
PopulateStatusFederationService populateStatusFederationService); }### Answer:
@Test public void hiveConf() { assertThat(hiveConf, is(notNullValue())); assertThat(hiveConf.get(CommonBeansTestContext.PROP_1), is(CommonBeansTestContext.VAL_1)); assertThat(hiveConf.get(CommonBeansTestContext.PROP_2), is(CommonBeansTestContext.VAL_2)); } |
### Question:
YamlStorageConfiguration { public boolean isOverwriteConfigOnShutdown() { return overwriteConfigOnShutdown; } void setOverwriteConfigOnShutdown(boolean overwriteConfigOnShutdown); boolean isOverwriteConfigOnShutdown(); }### Answer:
@Test public void defaultOverwriteConfigOnShutdown() { assertThat(configuration.isOverwriteConfigOnShutdown(), is(true)); } |
### Question:
YamlStorageConfiguration { public void setOverwriteConfigOnShutdown(boolean overwriteConfigOnShutdown) { this.overwriteConfigOnShutdown = overwriteConfigOnShutdown; } void setOverwriteConfigOnShutdown(boolean overwriteConfigOnShutdown); boolean isOverwriteConfigOnShutdown(); }### Answer:
@Test public void setOverwriteConfigOnShutdown() { configuration.setOverwriteConfigOnShutdown(false); assertThat(configuration.isOverwriteConfigOnShutdown(), is(false)); } |
### Question:
GraphiteConfiguration { public void setPort(int port) { this.port = port; } @PostConstruct void init(); boolean isEnabled(); int getPort(); void setPort(int port); String getHost(); void setHost(String host); String getPrefix(); void setPrefix(String prefix); long getPollInterval(); void setPollInterval(long pollInterval); TimeUnit getPollIntervalTimeUnit(); void setPollIntervalTimeUnit(TimeUnit pollIntervalTimeUnit); }### Answer:
@Test public void zeroPort() { graphiteConfiguration.setPort(0); Set<ConstraintViolation<GraphiteConfiguration>> violations = validator.validate(graphiteConfiguration); assertThat(violations.size(), is(1)); }
@Test public void negativePort() { graphiteConfiguration.setPort(-1); Set<ConstraintViolation<GraphiteConfiguration>> violations = validator.validate(graphiteConfiguration); assertThat(violations.size(), is(1)); } |
### Question:
TSetIpAddressProcessorFactory extends TProcessorFactory { @Override public TProcessor getProcessor(TTransport transport) { try { if (transport instanceof TSocket) { Socket socket = ((TSocket) transport).getSocket(); log.debug("Received a connection from ip: {}", socket.getInetAddress().getHostAddress()); } CloseableIHMSHandler baseHandler = federatedHMSHandlerFactory.create(); IHMSHandler handler = newRetryingHMSHandler(ExceptionWrappingHMSHandler.newProxyInstance(baseHandler), hiveConf, false); transportMonitor.monitor(transport, baseHandler); return new TSetIpAddressProcessor<>(handler); } catch (MetaException | ReflectiveOperationException | RuntimeException e) { throw new RuntimeException("Error creating TProcessor", e); } } @Autowired TSetIpAddressProcessorFactory(
HiveConf hiveConf,
FederatedHMSHandlerFactory federatedHMSHandlerFactory,
TTransportMonitor transportMonitor); @Override TProcessor getProcessor(TTransport transport); }### Answer:
@Test public void correctType() throws Exception { TProcessor processor = factory.getProcessor(transport); assertThat(TSetIpAddressProcessor.class.isAssignableFrom(processor.getClass()), is(true)); }
@Test public void connectionIsMonitored() throws Exception { factory.getProcessor(transport); ArgumentCaptor<TTransport> transportCaptor = ArgumentCaptor.forClass(TTransport.class); ArgumentCaptor<Closeable> handlerCaptor = ArgumentCaptor.forClass(Closeable.class); verify(transportMonitor).monitor(transportCaptor.capture(), handlerCaptor.capture()); assertThat(transportCaptor.getValue(), is(transport)); assertThat(handlerCaptor.getValue(), is(instanceOf(FederatedHMSHandler.class))); } |
### Question:
ExceptionWrappingHMSHandler implements InvocationHandler { public static IHMSHandler newProxyInstance(IHMSHandler baseHandler) { return (IHMSHandler) Proxy.newProxyInstance(ExceptionWrappingHMSHandler.class.getClassLoader(), new Class[] { IHMSHandler.class }, new ExceptionWrappingHMSHandler(baseHandler)); } ExceptionWrappingHMSHandler(IHMSHandler baseHandler); static IHMSHandler newProxyInstance(IHMSHandler baseHandler); @Override Object invoke(Object proxy, Method method, Object[] args); }### Answer:
@Test public void get_databaseNoExceptions() throws Exception { IHMSHandler handler = ExceptionWrappingHMSHandler.newProxyInstance(baseHandler); handler.get_database("bdp"); verify(baseHandler).get_database("bdp"); }
@Test public void get_databaseWaggleDanceServerException() throws Exception { expectedException.expect(MetaException.class); IHMSHandler handler = ExceptionWrappingHMSHandler.newProxyInstance(baseHandler); when(baseHandler.get_database("bdp")).thenThrow(new WaggleDanceServerException("waggle waggle!")); handler.get_database("bdp"); }
@Test public void get_databasNotAllowedException() throws Exception { expectedException.expect(MetaException.class); IHMSHandler handler = ExceptionWrappingHMSHandler.newProxyInstance(baseHandler); when(baseHandler.get_database("bdp")).thenThrow(new NotAllowedException("waggle waggle!")); handler.get_database("bdp"); }
@Test public void get_databaseRunTimeExceptionIsNotWrapped() throws Exception { expectedException.expect(RuntimeException.class); expectedException.expectMessage("generic non waggle dance exception"); IHMSHandler handler = ExceptionWrappingHMSHandler.newProxyInstance(baseHandler); when(baseHandler.get_database("bdp")).thenThrow(new RuntimeException("generic non waggle dance exception")); handler.get_database("bdp"); }
@Test public void get_databaseCheckedExceptionIsNotWrapped() throws Exception { expectedException.expect(NoSuchObjectException.class); expectedException.expectMessage("Does not exist!"); IHMSHandler handler = ExceptionWrappingHMSHandler.newProxyInstance(baseHandler); when(baseHandler.get_database("bdp")).thenThrow(new NoSuchObjectException("Does not exist!")); handler.get_database("bdp"); } |
### Question:
FederatedHMSHandlerFactory { public CloseableIHMSHandler create() { MappingEventListener service = createDatabaseMappingService(); MonitoredDatabaseMappingService monitoredService = new MonitoredDatabaseMappingService(service); CloseableIHMSHandler baseHandler = new FederatedHMSHandler(monitoredService, notifyingFederationService); HiveConf conf = new HiveConf(hiveConf); baseHandler.setConf(conf); return baseHandler; } @Autowired FederatedHMSHandlerFactory(
HiveConf hiveConf,
NotifyingFederationService notifyingFederationService,
MetaStoreMappingFactory metaStoreMappingFactory,
WaggleDanceConfiguration waggleDanceConfiguration,
QueryMapping queryMapping); CloseableIHMSHandler create(); }### Answer:
@Test public void typical() throws Exception { when(waggleDanceConfiguration.getDatabaseResolution()).thenReturn(DatabaseResolution.MANUAL); CloseableIHMSHandler handler = factory.create(); assertThat(handler, is(instanceOf(FederatedHMSHandler.class))); }
@Test public void prefixedDatabase() throws Exception { when(waggleDanceConfiguration.getDatabaseResolution()).thenReturn(DatabaseResolution.PREFIXED); factory = new FederatedHMSHandlerFactory(hiveConf, notifyingFederationService, metaStoreMappingFactory, waggleDanceConfiguration, queryMapping); CloseableIHMSHandler handler = factory.create(); assertThat(handler, is(instanceOf(FederatedHMSHandler.class))); }
@Test(expected = WaggleDanceException.class) public void noMode() { factory = new FederatedHMSHandlerFactory(hiveConf, notifyingFederationService, metaStoreMappingFactory, waggleDanceConfiguration, queryMapping); factory.create(); } |
### Question:
GraphiteConfiguration { public void setPollInterval(long pollInterval) { this.pollInterval = pollInterval; } @PostConstruct void init(); boolean isEnabled(); int getPort(); void setPort(int port); String getHost(); void setHost(String host); String getPrefix(); void setPrefix(String prefix); long getPollInterval(); void setPollInterval(long pollInterval); TimeUnit getPollIntervalTimeUnit(); void setPollIntervalTimeUnit(TimeUnit pollIntervalTimeUnit); }### Answer:
@Test public void zeroPollInterval() { graphiteConfiguration.setPollInterval(0); Set<ConstraintViolation<GraphiteConfiguration>> violations = validator.validate(graphiteConfiguration); assertThat(violations.size(), is(1)); }
@Test public void negativePollInterval() { graphiteConfiguration.setPollInterval(-1); Set<ConstraintViolation<GraphiteConfiguration>> violations = validator.validate(graphiteConfiguration); assertThat(violations.size(), is(1)); } |
### Question:
GraphiteConfiguration { public void setPollIntervalTimeUnit(TimeUnit pollIntervalTimeUnit) { this.pollIntervalTimeUnit = pollIntervalTimeUnit; } @PostConstruct void init(); boolean isEnabled(); int getPort(); void setPort(int port); String getHost(); void setHost(String host); String getPrefix(); void setPrefix(String prefix); long getPollInterval(); void setPollInterval(long pollInterval); TimeUnit getPollIntervalTimeUnit(); void setPollIntervalTimeUnit(TimeUnit pollIntervalTimeUnit); }### Answer:
@Test public void nullPollIntervalTimeUnit() { graphiteConfiguration.setPollIntervalTimeUnit(null); Set<ConstraintViolation<GraphiteConfiguration>> violations = validator.validate(graphiteConfiguration); assertThat(violations.size(), is(1)); } |
### Question:
AbstractMetaStore { public void setRemoteMetaStoreUris(String remoteMetaStoreUris) { this.remoteMetaStoreUris = remoteMetaStoreUris; } AbstractMetaStore(); AbstractMetaStore(String name, String remoteMetaStoreUris, AccessControlType accessControlType); AbstractMetaStore(
String name,
String remoteMetaStoreUris,
AccessControlType accessControlType,
List<String> writableDatabaseWhitelist); static FederatedMetaStore newFederatedInstance(String name, String remoteMetaStoreUris); static PrimaryMetaStore newPrimaryInstance(
String name,
String remoteMetaStoreUris,
AccessControlType accessControlType); static PrimaryMetaStore newPrimaryInstance(String name, String remoteMetaStoreUris); String getDatabasePrefix(); void setDatabasePrefix(String databasePrefix); String getName(); void setName(String name); String getRemoteMetaStoreUris(); void setRemoteMetaStoreUris(String remoteMetaStoreUris); MetastoreTunnel getMetastoreTunnel(); void setMetastoreTunnel(MetastoreTunnel metastoreTunnel); ConnectionType getConnectionType(); abstract FederationType getFederationType(); AccessControlType getAccessControlType(); void setAccessControlType(AccessControlType accessControlType); List<String> getWritableDatabaseWhiteList(); void setWritableDatabaseWhiteList(List<String> writableDatabaseWhitelist); long getLatency(); void setLatency(long latency); List<String> getMappedDatabases(); void setMappedDatabases(List<String> mappedDatabases); Map<String, String> getDatabaseNameMapping(); void setDatabaseNameMapping(Map<String, String> databaseNameMapping); @Transient HashBiMap<String, String> getDatabaseNameBiMapping(); @Transient MetaStoreStatus getStatus(); @Transient void setStatus(MetaStoreStatus status); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer:
@Test public void nullRemoteMetaStoreUris() { metaStore.setRemoteMetaStoreUris(null); Set<ConstraintViolation<T>> violations = validator.validate(metaStore); assertThat(violations.size(), is(1)); }
@Test public void emptyRemoteMetaStoreUris() { metaStore.setRemoteMetaStoreUris(" "); Set<ConstraintViolation<T>> violations = validator.validate(metaStore); assertThat(violations.size(), is(1)); } |
### Question:
WaggleDanceConfiguration { public void setPort(Integer port) { this.port = port; } Integer getPort(); void setPort(Integer port); boolean isVerbose(); void setVerbose(boolean verbose); int getDisconnectConnectionDelay(); void setDisconnectConnectionDelay(int disconnectConnectionDelay); TimeUnit getDisconnectTimeUnit(); void setDisconnectTimeUnit(TimeUnit disconnectTimeUnit); Map<String, String> getConfigurationProperties(); void setConfigurationProperties(Map<String, String> configurationProperties); void setDatabaseResolution(DatabaseResolution databaseResolution); DatabaseResolution getDatabaseResolution(); int getThriftServerStopTimeoutValInSeconds(); void setThriftServerStopTimeoutValInSeconds(int thriftServerStopTimeoutValInSeconds); int getThriftServerRequestTimeout(); void setThriftServerRequestTimeout(int thriftServerRequestTimeout); TimeUnit getThriftServerRequestTimeoutUnit(); void setThriftServerRequestTimeoutUnit(TimeUnit thriftServerRequestTimeoutUnit); int getStatusPollingDelay(); void setStatusPollingDelay(int statusPollingDelay); TimeUnit getStatusPollingDelayTimeUnit(); void setStatusPollingDelayTimeUnit(TimeUnit statusPollingDelayTimeUnit); }### Answer:
@Test public void nullPort() { waggleDanceConfiguration.setPort(null); Set<ConstraintViolation<WaggleDanceConfiguration>> violations = validator.validate(waggleDanceConfiguration); assertThat(violations.size(), is(1)); }
@Test public void zeroPort() { waggleDanceConfiguration.setPort(0); Set<ConstraintViolation<WaggleDanceConfiguration>> violations = validator.validate(waggleDanceConfiguration); assertThat(violations.size(), is(1)); }
@Test public void negativePort() { waggleDanceConfiguration.setPort(-1); Set<ConstraintViolation<WaggleDanceConfiguration>> violations = validator.validate(waggleDanceConfiguration); assertThat(violations.size(), is(1)); } |
### Question:
WaggleDanceConfiguration { public void setDisconnectConnectionDelay(int disconnectConnectionDelay) { this.disconnectConnectionDelay = disconnectConnectionDelay; } Integer getPort(); void setPort(Integer port); boolean isVerbose(); void setVerbose(boolean verbose); int getDisconnectConnectionDelay(); void setDisconnectConnectionDelay(int disconnectConnectionDelay); TimeUnit getDisconnectTimeUnit(); void setDisconnectTimeUnit(TimeUnit disconnectTimeUnit); Map<String, String> getConfigurationProperties(); void setConfigurationProperties(Map<String, String> configurationProperties); void setDatabaseResolution(DatabaseResolution databaseResolution); DatabaseResolution getDatabaseResolution(); int getThriftServerStopTimeoutValInSeconds(); void setThriftServerStopTimeoutValInSeconds(int thriftServerStopTimeoutValInSeconds); int getThriftServerRequestTimeout(); void setThriftServerRequestTimeout(int thriftServerRequestTimeout); TimeUnit getThriftServerRequestTimeoutUnit(); void setThriftServerRequestTimeoutUnit(TimeUnit thriftServerRequestTimeoutUnit); int getStatusPollingDelay(); void setStatusPollingDelay(int statusPollingDelay); TimeUnit getStatusPollingDelayTimeUnit(); void setStatusPollingDelayTimeUnit(TimeUnit statusPollingDelayTimeUnit); }### Answer:
@Test public void zeroDisconnectConnectionDelay() { waggleDanceConfiguration.setDisconnectConnectionDelay(0); Set<ConstraintViolation<WaggleDanceConfiguration>> violations = validator.validate(waggleDanceConfiguration); assertThat(violations.size(), is(1)); }
@Test public void negativeDisconnectConnectionDelay() { waggleDanceConfiguration.setDisconnectConnectionDelay(-1); Set<ConstraintViolation<WaggleDanceConfiguration>> violations = validator.validate(waggleDanceConfiguration); assertThat(violations.size(), is(1)); } |
### Question:
WaggleDanceConfiguration { public void setDisconnectTimeUnit(TimeUnit disconnectTimeUnit) { this.disconnectTimeUnit = disconnectTimeUnit; } Integer getPort(); void setPort(Integer port); boolean isVerbose(); void setVerbose(boolean verbose); int getDisconnectConnectionDelay(); void setDisconnectConnectionDelay(int disconnectConnectionDelay); TimeUnit getDisconnectTimeUnit(); void setDisconnectTimeUnit(TimeUnit disconnectTimeUnit); Map<String, String> getConfigurationProperties(); void setConfigurationProperties(Map<String, String> configurationProperties); void setDatabaseResolution(DatabaseResolution databaseResolution); DatabaseResolution getDatabaseResolution(); int getThriftServerStopTimeoutValInSeconds(); void setThriftServerStopTimeoutValInSeconds(int thriftServerStopTimeoutValInSeconds); int getThriftServerRequestTimeout(); void setThriftServerRequestTimeout(int thriftServerRequestTimeout); TimeUnit getThriftServerRequestTimeoutUnit(); void setThriftServerRequestTimeoutUnit(TimeUnit thriftServerRequestTimeoutUnit); int getStatusPollingDelay(); void setStatusPollingDelay(int statusPollingDelay); TimeUnit getStatusPollingDelayTimeUnit(); void setStatusPollingDelayTimeUnit(TimeUnit statusPollingDelayTimeUnit); }### Answer:
@Test public void nullDisconnectTimeUnit() { waggleDanceConfiguration.setDisconnectTimeUnit(null); Set<ConstraintViolation<WaggleDanceConfiguration>> violations = validator.validate(waggleDanceConfiguration); assertThat(violations.size(), is(1)); } |
### Question:
WaggleDanceConfiguration { public void setConfigurationProperties(Map<String, String> configurationProperties) { this.configurationProperties = configurationProperties; } Integer getPort(); void setPort(Integer port); boolean isVerbose(); void setVerbose(boolean verbose); int getDisconnectConnectionDelay(); void setDisconnectConnectionDelay(int disconnectConnectionDelay); TimeUnit getDisconnectTimeUnit(); void setDisconnectTimeUnit(TimeUnit disconnectTimeUnit); Map<String, String> getConfigurationProperties(); void setConfigurationProperties(Map<String, String> configurationProperties); void setDatabaseResolution(DatabaseResolution databaseResolution); DatabaseResolution getDatabaseResolution(); int getThriftServerStopTimeoutValInSeconds(); void setThriftServerStopTimeoutValInSeconds(int thriftServerStopTimeoutValInSeconds); int getThriftServerRequestTimeout(); void setThriftServerRequestTimeout(int thriftServerRequestTimeout); TimeUnit getThriftServerRequestTimeoutUnit(); void setThriftServerRequestTimeoutUnit(TimeUnit thriftServerRequestTimeoutUnit); int getStatusPollingDelay(); void setStatusPollingDelay(int statusPollingDelay); TimeUnit getStatusPollingDelayTimeUnit(); void setStatusPollingDelayTimeUnit(TimeUnit statusPollingDelayTimeUnit); }### Answer:
@Test public void nullConfigurationProperties() { waggleDanceConfiguration.setConfigurationProperties(null); Set<ConstraintViolation<WaggleDanceConfiguration>> violations = validator.validate(waggleDanceConfiguration); assertThat(violations.size(), is(0)); }
@Test public void emptyConfigurationProperties() { waggleDanceConfiguration.setConfigurationProperties(ImmutableMap.of()); Set<ConstraintViolation<WaggleDanceConfiguration>> violations = validator.validate(waggleDanceConfiguration); assertThat(violations.size(), is(0)); } |
### Question:
WaggleDanceConfiguration { public void setDatabaseResolution(DatabaseResolution databaseResolution) { this.databaseResolution = databaseResolution; } Integer getPort(); void setPort(Integer port); boolean isVerbose(); void setVerbose(boolean verbose); int getDisconnectConnectionDelay(); void setDisconnectConnectionDelay(int disconnectConnectionDelay); TimeUnit getDisconnectTimeUnit(); void setDisconnectTimeUnit(TimeUnit disconnectTimeUnit); Map<String, String> getConfigurationProperties(); void setConfigurationProperties(Map<String, String> configurationProperties); void setDatabaseResolution(DatabaseResolution databaseResolution); DatabaseResolution getDatabaseResolution(); int getThriftServerStopTimeoutValInSeconds(); void setThriftServerStopTimeoutValInSeconds(int thriftServerStopTimeoutValInSeconds); int getThriftServerRequestTimeout(); void setThriftServerRequestTimeout(int thriftServerRequestTimeout); TimeUnit getThriftServerRequestTimeoutUnit(); void setThriftServerRequestTimeoutUnit(TimeUnit thriftServerRequestTimeoutUnit); int getStatusPollingDelay(); void setStatusPollingDelay(int statusPollingDelay); TimeUnit getStatusPollingDelayTimeUnit(); void setStatusPollingDelayTimeUnit(TimeUnit statusPollingDelayTimeUnit); }### Answer:
@Test public void nullDatabaseResolution() { waggleDanceConfiguration.setDatabaseResolution(null); Set<ConstraintViolation<WaggleDanceConfiguration>> violations = validator.validate(waggleDanceConfiguration); assertThat(violations.size(), is(1)); } |
### Question:
WaggleDanceConfiguration { public int getStatusPollingDelay() { return statusPollingDelay; } Integer getPort(); void setPort(Integer port); boolean isVerbose(); void setVerbose(boolean verbose); int getDisconnectConnectionDelay(); void setDisconnectConnectionDelay(int disconnectConnectionDelay); TimeUnit getDisconnectTimeUnit(); void setDisconnectTimeUnit(TimeUnit disconnectTimeUnit); Map<String, String> getConfigurationProperties(); void setConfigurationProperties(Map<String, String> configurationProperties); void setDatabaseResolution(DatabaseResolution databaseResolution); DatabaseResolution getDatabaseResolution(); int getThriftServerStopTimeoutValInSeconds(); void setThriftServerStopTimeoutValInSeconds(int thriftServerStopTimeoutValInSeconds); int getThriftServerRequestTimeout(); void setThriftServerRequestTimeout(int thriftServerRequestTimeout); TimeUnit getThriftServerRequestTimeoutUnit(); void setThriftServerRequestTimeoutUnit(TimeUnit thriftServerRequestTimeoutUnit); int getStatusPollingDelay(); void setStatusPollingDelay(int statusPollingDelay); TimeUnit getStatusPollingDelayTimeUnit(); void setStatusPollingDelayTimeUnit(TimeUnit statusPollingDelayTimeUnit); }### Answer:
@Test public void setterGetterStatusPollingDelayDefault() { assertThat(waggleDanceConfiguration.getStatusPollingDelay(), is(5)); } |
### Question:
WaggleDanceConfiguration { public TimeUnit getStatusPollingDelayTimeUnit() { return statusPollingDelayTimeUnit; } Integer getPort(); void setPort(Integer port); boolean isVerbose(); void setVerbose(boolean verbose); int getDisconnectConnectionDelay(); void setDisconnectConnectionDelay(int disconnectConnectionDelay); TimeUnit getDisconnectTimeUnit(); void setDisconnectTimeUnit(TimeUnit disconnectTimeUnit); Map<String, String> getConfigurationProperties(); void setConfigurationProperties(Map<String, String> configurationProperties); void setDatabaseResolution(DatabaseResolution databaseResolution); DatabaseResolution getDatabaseResolution(); int getThriftServerStopTimeoutValInSeconds(); void setThriftServerStopTimeoutValInSeconds(int thriftServerStopTimeoutValInSeconds); int getThriftServerRequestTimeout(); void setThriftServerRequestTimeout(int thriftServerRequestTimeout); TimeUnit getThriftServerRequestTimeoutUnit(); void setThriftServerRequestTimeoutUnit(TimeUnit thriftServerRequestTimeoutUnit); int getStatusPollingDelay(); void setStatusPollingDelay(int statusPollingDelay); TimeUnit getStatusPollingDelayTimeUnit(); void setStatusPollingDelayTimeUnit(TimeUnit statusPollingDelayTimeUnit); }### Answer:
@Test public void setterGetterStatusPollingDelayTimeUnitDefault() { assertThat(waggleDanceConfiguration.getStatusPollingDelayTimeUnit(), is(TimeUnit.MINUTES)); } |
### Question:
CloseableThriftHiveMetastoreIfaceClientFactory { public CloseableThriftHiveMetastoreIface newInstance(AbstractMetaStore metaStore) { String uris = MetaStoreUriNormaliser.normaliseMetaStoreUris(metaStore.getRemoteMetaStoreUris()); String name = metaStore.getName().toLowerCase(Locale.ROOT); int connectionTimeout = Math.max(1, defaultConnectionTimeout + (int) metaStore.getLatency()); if (metaStore.getConnectionType() == TUNNELED) { return tunnelingMetaStoreClientFactory .newInstance(uris, metaStore.getMetastoreTunnel(), name, DEFAULT_CLIENT_FACTORY_RECONNECTION_RETRY, connectionTimeout); } Map<String, String> properties = new HashMap<>(); properties.put(ConfVars.METASTOREURIS.varname, uris); HiveConfFactory confFactory = new HiveConfFactory(Collections.emptyList(), properties); return defaultMetaStoreClientFactory .newInstance(confFactory.newInstance(), "waggledance-" + name, DEFAULT_CLIENT_FACTORY_RECONNECTION_RETRY, connectionTimeout); } CloseableThriftHiveMetastoreIfaceClientFactory(
TunnelingMetaStoreClientFactory tunnelingMetaStoreClientFactory,
DefaultMetaStoreClientFactory defaultMetaStoreClientFactory); CloseableThriftHiveMetastoreIface newInstance(AbstractMetaStore metaStore); }### Answer:
@Test public void defaultFactory() { ArgumentCaptor<HiveConf> hiveConfCaptor = ArgumentCaptor.forClass(HiveConf.class); factory.newInstance(newFederatedInstance("fed1", THRIFT_URI)); verify(defaultMetaStoreClientFactory).newInstance(hiveConfCaptor.capture(), eq( "waggledance-fed1"), eq(3), eq(2000)); verifyZeroInteractions(tunnelingMetaStoreClientFactory); HiveConf hiveConf = hiveConfCaptor.getValue(); assertThat(hiveConf.getVar(ConfVars.METASTOREURIS), is(THRIFT_URI)); }
@Test public void tunnelingFactory() { MetastoreTunnel metastoreTunnel = new MetastoreTunnel(); metastoreTunnel.setLocalhost("local-machine"); metastoreTunnel.setPort(2222); metastoreTunnel.setRoute("a -> b -> c"); metastoreTunnel.setKnownHosts("knownHosts"); metastoreTunnel.setPrivateKeys("privateKeys"); metastoreTunnel.setTimeout(123); AbstractMetaStore federatedMetaStore = newFederatedInstance("fed1", THRIFT_URI); federatedMetaStore.setMetastoreTunnel(metastoreTunnel); factory.newInstance(federatedMetaStore); verify(tunnelingMetaStoreClientFactory).newInstance(THRIFT_URI, metastoreTunnel, "fed1", 3, 2000); verifyZeroInteractions(defaultMetaStoreClientFactory); } |
### Question:
AbstractMetaStore { public void setMetastoreTunnel(MetastoreTunnel metastoreTunnel) { this.metastoreTunnel = metastoreTunnel; } AbstractMetaStore(); AbstractMetaStore(String name, String remoteMetaStoreUris, AccessControlType accessControlType); AbstractMetaStore(
String name,
String remoteMetaStoreUris,
AccessControlType accessControlType,
List<String> writableDatabaseWhitelist); static FederatedMetaStore newFederatedInstance(String name, String remoteMetaStoreUris); static PrimaryMetaStore newPrimaryInstance(
String name,
String remoteMetaStoreUris,
AccessControlType accessControlType); static PrimaryMetaStore newPrimaryInstance(String name, String remoteMetaStoreUris); String getDatabasePrefix(); void setDatabasePrefix(String databasePrefix); String getName(); void setName(String name); String getRemoteMetaStoreUris(); void setRemoteMetaStoreUris(String remoteMetaStoreUris); MetastoreTunnel getMetastoreTunnel(); void setMetastoreTunnel(MetastoreTunnel metastoreTunnel); ConnectionType getConnectionType(); abstract FederationType getFederationType(); AccessControlType getAccessControlType(); void setAccessControlType(AccessControlType accessControlType); List<String> getWritableDatabaseWhiteList(); void setWritableDatabaseWhiteList(List<String> writableDatabaseWhitelist); long getLatency(); void setLatency(long latency); List<String> getMappedDatabases(); void setMappedDatabases(List<String> mappedDatabases); Map<String, String> getDatabaseNameMapping(); void setDatabaseNameMapping(Map<String, String> databaseNameMapping); @Transient HashBiMap<String, String> getDatabaseNameBiMapping(); @Transient MetaStoreStatus getStatus(); @Transient void setStatus(MetaStoreStatus status); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer:
@Test public void validMetastoreTunnel() { metaStore.setMetastoreTunnel(newMetastoreTunnel()); Set<ConstraintViolation<T>> violations = validator.validate(metaStore); assertThat(violations.size(), is(0)); }
@Test public void invalidMetastoreTunnel() { MetastoreTunnel metastoreTunnel = newMetastoreTunnel(); metastoreTunnel.setPort(-1); metaStore.setMetastoreTunnel(metastoreTunnel); Set<ConstraintViolation<T>> violations = validator.validate(metaStore); assertThat(violations.size(), is(1)); } |
### Question:
TunnelableFactorySupplier { public TunnelableFactory<CloseableThriftHiveMetastoreIface> get(MetastoreTunnel metastoreTunnel) { return new TunnelableFactory<>(buildSshSettings(metastoreTunnel)); } TunnelableFactory<CloseableThriftHiveMetastoreIface> get(MetastoreTunnel metastoreTunnel); }### Answer:
@Test public void get() { TunnelableFactory<CloseableThriftHiveMetastoreIface> tunnelableFactory = supplier.get(metastoreTunnel); assertNotNull(tunnelableFactory); } |
### Question:
TunnelableFactorySupplier { @VisibleForTesting SshSettings buildSshSettings(MetastoreTunnel metastoreTunnel) { return SshSettings .builder() .withSshPort(metastoreTunnel.getPort()) .withSessionTimeout(metastoreTunnel.getTimeout()) .withRoute(metastoreTunnel.getRoute()) .withKnownHosts(metastoreTunnel.getKnownHosts()) .withLocalhost(metastoreTunnel.getLocalhost()) .withPrivateKeys(metastoreTunnel.getPrivateKeys()) .withStrictHostKeyChecking(metastoreTunnel.isStrictHostKeyCheckingEnabled()) .build(); } TunnelableFactory<CloseableThriftHiveMetastoreIface> get(MetastoreTunnel metastoreTunnel); }### Answer:
@Test public void buildSshSettings() { SshSettings sshSettings = supplier.buildSshSettings(metastoreTunnel); assertThat(sshSettings.getRoute(), is(TUNNEL_ROUTE)); assertThat(sshSettings.getPrivateKeys(), is(Lists.newArrayList(TUNNEL_PRIVATE_KEY))); assertThat(sshSettings.getKnownHosts(), is(TUNNEL_KNOWN_HOSTS)); assertThat(sshSettings.isStrictHostKeyChecking(), is(true)); } |
### Question:
HiveMetaStoreClientSupplier implements TunnelableSupplier<CloseableThriftHiveMetastoreIface> { @Override public CloseableThriftHiveMetastoreIface get() { return factory.newInstance(hiveConf, name, reconnectionRetries, connectionTimeout); } HiveMetaStoreClientSupplier(MetaStoreClientFactory factory, HiveConf hiveConf, String name, int reconnectionRetries, int connectionTimeout); @Override CloseableThriftHiveMetastoreIface get(); }### Answer:
@Test public void getMetaStoreClientFactoryInstance() { String name = "test"; int reconnectionRetries = 10; int connectionTimeout = 10; HiveMetaStoreClientSupplier supplier = new HiveMetaStoreClientSupplier(factory, hiveConf, name, reconnectionRetries, connectionTimeout); supplier.get(); verify(factory).newInstance(hiveConf, name, reconnectionRetries, connectionTimeout); } |
### Question:
LocalHiveConfFactory { HiveConf newInstance(String localHost, int localPort, HiveConf hiveConf) { HiveConf localHiveConf = new HiveConf(hiveConf); String proxyMetaStoreUris = "thrift: localHiveConf.setVar(HiveConf.ConfVars.METASTOREURIS, proxyMetaStoreUris); return localHiveConf; } }### Answer:
@Test public void getCorrectHiveConf() { String localHost = "localHost"; int localPort = 10; String expectedUri = "thrift: HiveConf hiveConf = new HiveConf(); HiveConf conf = new LocalHiveConfFactory().newInstance(localHost, localPort, hiveConf); assertThat(conf.getVar(HiveConf.ConfVars.METASTOREURIS), is(expectedUri)); assertThat(conf, not(sameInstance(hiveConf))); } |
### Question:
DefaultMetaStoreClientFactory implements MetaStoreClientFactory { @Override public CloseableThriftHiveMetastoreIface newInstance( HiveConf hiveConf, String name, int reconnectionRetries, int connectionTimeout) { return newInstance(name, reconnectionRetries, new ThriftMetastoreClientManager(hiveConf, new HiveCompatibleThriftHiveMetastoreIfaceFactory(), connectionTimeout)); } @Override CloseableThriftHiveMetastoreIface newInstance(
HiveConf hiveConf,
String name,
int reconnectionRetries,
int connectionTimeout); }### Answer:
@Test public void isOpen() { when(base.isOpen()).thenReturn(true); CloseableThriftHiveMetastoreIface iface = factory.newInstance("name", RECONNECTION_RETRIES, base); boolean result = iface.isOpen(); assertThat(result, is(true)); verify(base, never()).reconnect(); }
@Test public void isOpenWithReconnection() { when(base.isOpen()).thenReturn(false).thenReturn(true); CloseableThriftHiveMetastoreIface iface = factory.newInstance("name", RECONNECTION_RETRIES, base); boolean result = iface.isOpen(); assertThat(result, is(true)); verify(base).reconnect(); }
@Test public void isOpenThrowsException() { when(base.isOpen()).thenThrow(new RuntimeException()); CloseableThriftHiveMetastoreIface iface = factory.newInstance("name", RECONNECTION_RETRIES, base); boolean result = iface.isOpen(); assertThat(result, is(false)); }
@Test public void closeNullBase() throws Exception { CloseableThriftHiveMetastoreIface iface = factory.newInstance("name", RECONNECTION_RETRIES, null); iface.close(); verify(base, never()).close(); }
@Test public void defaultMethodCall() throws Exception { when(base.getClient()).thenReturn(client); when(client.getName()).thenReturn("ourName"); CloseableThriftHiveMetastoreIface iface = factory.newInstance("name", RECONNECTION_RETRIES, base); String result = iface.getName(); assertThat(result, is("ourName")); }
@Test public void defaultMethodCallThrowsTransportExceptionRetries() throws TException { when(base.getClient()).thenReturn(client); when(client.getName()).thenThrow(new TTransportException()).thenReturn("ourName"); CloseableThriftHiveMetastoreIface iface = factory.newInstance("name", RECONNECTION_RETRIES, base); String result = iface.getName(); assertThat(result, is("ourName")); verify(base).reconnect(); }
@Test(expected = MetastoreUnavailableException.class) public void shutdownThrowsTransportExceptionNoRetry() throws TException { when(base.getClient()).thenReturn(client); doThrow(new TTransportException()).when(client).shutdown(); CloseableThriftHiveMetastoreIface iface = factory.newInstance("name", RECONNECTION_RETRIES, base); iface.shutdown(); }
@Test(expected = MetastoreUnavailableException.class) public void defaultMethodCallThrowsTransportExceptionNoRetriesLeft() throws TException { when(base.getClient()).thenReturn(client); when(client.getName()).thenThrow(new TTransportException()); CloseableThriftHiveMetastoreIface iface = factory.newInstance("name", 0, base); iface.getName(); }
@Test(expected = TException.class) public void defaultMethodCallThrowsRealException() throws TException { when(base.getClient()).thenReturn(client); when(client.getName()).thenThrow(new TException()); CloseableThriftHiveMetastoreIface iface = factory.newInstance("name", RECONNECTION_RETRIES, base); iface.getName(); } |
### Question:
ThriftMetastoreClientManager implements Closeable { void open() { if (isConnected) { return; } TException te = null; boolean useSasl = conf.getBoolVar(ConfVars.METASTORE_USE_THRIFT_SASL); boolean useFramedTransport = conf.getBoolVar(ConfVars.METASTORE_USE_THRIFT_FRAMED_TRANSPORT); boolean useCompactProtocol = conf.getBoolVar(ConfVars.METASTORE_USE_THRIFT_COMPACT_PROTOCOL); int clientSocketTimeout = (int) conf.getTimeVar(ConfVars.METASTORE_CLIENT_SOCKET_TIMEOUT, TimeUnit.MILLISECONDS); for (int attempt = 0; !isConnected && (attempt < retries); ++attempt) { for (URI store : metastoreUris) { LOG.info("Trying to connect to metastore with URI " + store); try { transport = new TSocket(store.getHost(), store.getPort(), clientSocketTimeout, connectionTimeout); if (useSasl) { try { HadoopThriftAuthBridge.Client authBridge = ShimLoader.getHadoopThriftAuthBridge().createClient(); String tokenSig = conf.getVar(ConfVars.METASTORE_TOKEN_SIGNATURE); String tokenStrForm = Utils.getTokenStrForm(tokenSig); if (tokenStrForm != null) { transport = authBridge .createClientTransport(null, store.getHost(), "DIGEST", tokenStrForm, transport, MetaStoreUtils.getMetaStoreSaslProperties(conf)); } else { String principalConfig = conf.getVar(HiveConf.ConfVars.METASTORE_KERBEROS_PRINCIPAL); transport = authBridge .createClientTransport(principalConfig, store.getHost(), "KERBEROS", null, transport, MetaStoreUtils.getMetaStoreSaslProperties(conf)); } } catch (IOException ioe) { LOG.error("Couldn't create client transport", ioe); throw new MetaException(ioe.toString()); } } else if (useFramedTransport) { transport = new TFramedTransport(transport); } TProtocol protocol; if (useCompactProtocol) { protocol = new TCompactProtocol(transport); } else { protocol = new TBinaryProtocol(transport); } client = hiveCompatibleThriftHiveMetastoreIfaceFactory.newInstance(new ThriftHiveMetastore.Client(protocol)); try { transport.open(); LOG .info("Opened a connection to metastore '" + store + "', total current connections to all metastores: " + CONN_COUNT.incrementAndGet()); isConnected = true; } catch (TException e) { te = e; if (LOG.isDebugEnabled()) { LOG.warn("Failed to connect to the MetaStore Server...", e); } else { LOG.warn("Failed to connect to the MetaStore Server..."); } } } catch (MetaException e) { LOG.error("Unable to connect to metastore with URI " + store + " in attempt " + attempt, e); } if (isConnected) { break; } } if (!isConnected && (retryDelaySeconds > 0) && ((attempt + 1) < retries)) { try { LOG.info("Waiting " + retryDelaySeconds + " seconds before next connection attempt."); Thread.sleep(retryDelaySeconds * 1000); } catch (InterruptedException ignore) {} } } if (!isConnected) { throw new RuntimeException("Could not connect to meta store using any of the URIs provided. Most recent failure: " + StringUtils.stringifyException(te)); } LOG.info("Connected to metastore."); } ThriftMetastoreClientManager(
HiveConf conf,
HiveCompatibleThriftHiveMetastoreIfaceFactory hiveCompatibleThriftHiveMetastoreIfaceFactory,
int connectionTimeout); @Override void close(); }### Answer:
@Test(expected = RuntimeException.class) public void openSlowConnection() { client = new ThriftMetastoreClientManager(hiveConf, hiveCompatibleThriftHiveMetastoreIfaceFactory, 1); client.open(); } |
### Question:
AbstractMetaStore { public void setName(String name) { this.name = name; } AbstractMetaStore(); AbstractMetaStore(String name, String remoteMetaStoreUris, AccessControlType accessControlType); AbstractMetaStore(
String name,
String remoteMetaStoreUris,
AccessControlType accessControlType,
List<String> writableDatabaseWhitelist); static FederatedMetaStore newFederatedInstance(String name, String remoteMetaStoreUris); static PrimaryMetaStore newPrimaryInstance(
String name,
String remoteMetaStoreUris,
AccessControlType accessControlType); static PrimaryMetaStore newPrimaryInstance(String name, String remoteMetaStoreUris); String getDatabasePrefix(); void setDatabasePrefix(String databasePrefix); String getName(); void setName(String name); String getRemoteMetaStoreUris(); void setRemoteMetaStoreUris(String remoteMetaStoreUris); MetastoreTunnel getMetastoreTunnel(); void setMetastoreTunnel(MetastoreTunnel metastoreTunnel); ConnectionType getConnectionType(); abstract FederationType getFederationType(); AccessControlType getAccessControlType(); void setAccessControlType(AccessControlType accessControlType); List<String> getWritableDatabaseWhiteList(); void setWritableDatabaseWhiteList(List<String> writableDatabaseWhitelist); long getLatency(); void setLatency(long latency); List<String> getMappedDatabases(); void setMappedDatabases(List<String> mappedDatabases); Map<String, String> getDatabaseNameMapping(); void setDatabaseNameMapping(Map<String, String> databaseNameMapping); @Transient HashBiMap<String, String> getDatabaseNameBiMapping(); @Transient MetaStoreStatus getStatus(); @Transient void setStatus(MetaStoreStatus status); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer:
@Test public void nullName() { metaStore.setName(null); Set<ConstraintViolation<T>> violations = validator.validate(metaStore); assertThat(violations.size(), is(1)); }
@Test public void emptyName() { metaStore.setName(" "); Set<ConstraintViolation<T>> violations = validator.validate(metaStore); assertThat(violations.size(), is(1)); } |
### Question:
MetaStoreMappingDecorator implements MetaStoreMapping { @Override public MetaStoreMapping checkWritePermissions(String databaseName) { return metaStoreMapping.checkWritePermissions(databaseName); } MetaStoreMappingDecorator(MetaStoreMapping metaStoreMapping); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override void close(); @Override Iface getClient(); @Override String getDatabasePrefix(); @Override String getMetastoreMappingName(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override long getLatency(); }### Answer:
@Test public void checkWritePermissions() throws Exception { decorator.checkWritePermissions("db"); verify(metaStoreMapping).checkWritePermissions("db"); } |
### Question:
MetaStoreMappingDecorator implements MetaStoreMapping { @Override public void close() throws IOException { metaStoreMapping.close(); } MetaStoreMappingDecorator(MetaStoreMapping metaStoreMapping); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override void close(); @Override Iface getClient(); @Override String getDatabasePrefix(); @Override String getMetastoreMappingName(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override long getLatency(); }### Answer:
@Test public void close() throws Exception { decorator.close(); verify(metaStoreMapping).close(); } |
### Question:
MetaStoreMappingDecorator implements MetaStoreMapping { @Override public void createDatabase(Database database) throws AlreadyExistsException, InvalidObjectException, MetaException, TException { metaStoreMapping.createDatabase(database); } MetaStoreMappingDecorator(MetaStoreMapping metaStoreMapping); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override void close(); @Override Iface getClient(); @Override String getDatabasePrefix(); @Override String getMetastoreMappingName(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override long getLatency(); }### Answer:
@Test public void createDatabase() throws Exception { Database database = new Database(); decorator.createDatabase(database); verify(metaStoreMapping).createDatabase(database); } |
### Question:
MetaStoreMappingDecorator implements MetaStoreMapping { @Override public Iface getClient() { return metaStoreMapping.getClient(); } MetaStoreMappingDecorator(MetaStoreMapping metaStoreMapping); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override void close(); @Override Iface getClient(); @Override String getDatabasePrefix(); @Override String getMetastoreMappingName(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override long getLatency(); }### Answer:
@Test public void getClient() throws Exception { when(metaStoreMapping.getClient()).thenReturn(client); Iface result = decorator.getClient(); assertThat(result, is(client)); } |
### Question:
MetaStoreMappingDecorator implements MetaStoreMapping { @Override public String getDatabasePrefix() { return metaStoreMapping.getDatabasePrefix(); } MetaStoreMappingDecorator(MetaStoreMapping metaStoreMapping); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override void close(); @Override Iface getClient(); @Override String getDatabasePrefix(); @Override String getMetastoreMappingName(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override long getLatency(); }### Answer:
@Test public void getDatabasePrefix() throws Exception { when(metaStoreMapping.getDatabasePrefix()).thenReturn("pre"); String result = decorator.getDatabasePrefix(); assertThat(result, is("pre")); } |
### Question:
MetaStoreMappingDecorator implements MetaStoreMapping { @Override public long getLatency() { return metaStoreMapping.getLatency(); } MetaStoreMappingDecorator(MetaStoreMapping metaStoreMapping); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override void close(); @Override Iface getClient(); @Override String getDatabasePrefix(); @Override String getMetastoreMappingName(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override long getLatency(); }### Answer:
@Test public void getLatency() throws Exception { when(metaStoreMapping.getLatency()).thenReturn(1L); long result = decorator.getLatency(); assertThat(result, is(1L)); } |
### Question:
SimpleXPathBasedCheck extends SonarXmlCheck { public XPathExpression getXPathExpression(String expression) { try { return xpath.compile(expression); } catch (XPathExpressionException e) { throw new IllegalStateException(String.format("[%s] Fail to compile XPath expression '%s'.", ruleKey(), expression), e); } } XPathExpression getXPathExpression(String expression); @CheckForNull NodeList evaluate(XPathExpression expression, Node node); List<Node> evaluateAsList(XPathExpression expression, Node node); }### Answer:
@Test(expected = IllegalStateException.class) public void test_invalid_xpath_compilation_throws_exception() throws Exception { new SimpleXPathBasedCheck() { XPathExpression failing = getXPathExpression("boolean(a"); @Override public void scanFile(XmlFile file) { } }; } |
### Question:
BuiltInQualityProfileJsonLoader { public static void load(NewBuiltInQualityProfile profile, String repositoryKey, String jsonProfilePath) { Set<String> activeKeys = loadActiveKeysFromJsonProfile(jsonProfilePath); for (String activeKey : activeKeys) { profile.activateRule(repositoryKey, activeKey); } } private BuiltInQualityProfileJsonLoader(); static void load(NewBuiltInQualityProfile profile, String repositoryKey, String jsonProfilePath); static Set<String> loadActiveKeysFromJsonProfile(String profilePath); }### Answer:
@Test public void fails_when_activating_rules_more_than_once() { NewBuiltInQualityProfile newProfile = testContext.createBuiltInQualityProfile(PROFILE_NAME, LANGUAGE); BuiltInQualityProfileJsonLoader.load(newProfile, REPOSITORY_KEY, PROFILE_PATH); thrown.expect(IllegalArgumentException.class); thrown.expectMessage("The rule 'repo-key:S100' is already activated"); BuiltInQualityProfileJsonLoader.load(newProfile, REPOSITORY_KEY, PROFILE_PATH); }
@Test public void fails_when_no_profile_found() { thrown.expect(IllegalStateException.class); thrown.expectMessage("Can't read resource: /wrong/path/Sonar_way_profile.json"); NewBuiltInQualityProfile newProfile = testContext.createBuiltInQualityProfile(PROFILE_NAME, LANGUAGE); BuiltInQualityProfileJsonLoader.load(newProfile, REPOSITORY_KEY, "/wrong/path/Sonar_way_profile.json"); }
@Test public void fails_when_no_rule_keys_in_profile() { thrown.expect(IllegalStateException.class); thrown.expectMessage("missing 'ruleKeys'"); NewBuiltInQualityProfile newProfile = testContext.createBuiltInQualityProfile(PROFILE_NAME, LANGUAGE); BuiltInQualityProfileJsonLoader.load(newProfile, REPOSITORY_KEY, "org/sonarsource/analyzer/commons/Sonar_way_profile_no_rule_keys.json"); }
@Test public void should_activate_hotspots() { NewBuiltInQualityProfile newProfile = testContext.createBuiltInQualityProfile(PROFILE_NAME, LANGUAGE); String profilePath = "org/sonarsource/analyzer/commons/Sonar_way_profile_with_hotspots.json"; BuiltInQualityProfileJsonLoader.load(newProfile, REPOSITORY_KEY, profilePath); newProfile.done(); BuiltInQualityProfile profile = testContext.profile(LANGUAGE, PROFILE_NAME); List<BuiltInActiveRule> activeRules = profile.rules(); assertThat(activeRules).extracting("ruleKey").containsExactlyInAnyOrder("S100", "S110", "S2092"); }
@Test public void load_profile_keys() { NewBuiltInQualityProfile newProfile = testContext.createBuiltInQualityProfile(PROFILE_NAME, LANGUAGE); BuiltInQualityProfileJsonLoader.load(newProfile, REPOSITORY_KEY, PROFILE_PATH); newProfile.done(); BuiltInQualityProfile profile = testContext.profile(LANGUAGE, PROFILE_NAME); List<BuiltInActiveRule> activeRules = profile.rules(); assertThat(activeRules).hasSize(2); assertThat(profile.rule(RuleKey.of(REPOSITORY_KEY, "S100"))).isNotNull(); assertThat(profile.rule(RuleKey.of(REPOSITORY_KEY, "S110"))).isNotNull(); assertThat(profile.rule(RuleKey.of(REPOSITORY_KEY, "S123"))).isNull(); assertThat(profile.rule(RuleKey.of(REPOSITORY_KEY, "S666"))).isNull(); } |
### Question:
RuleMetadataLoader { public void addRulesByRuleKey(NewRepository repository, List<String> ruleKeys) { for (String ruleKey : ruleKeys) { addRuleByRuleKey(repository, ruleKey); } } RuleMetadataLoader(String resourceFolder); RuleMetadataLoader(String resourceFolder, String defaultProfilePath); private RuleMetadataLoader(String resourceFolder, Set<String> activatedByDefault); void addRulesByAnnotatedClass(NewRepository repository, List<Class<?>> ruleClasses); void addRulesByRuleKey(NewRepository repository, List<String> ruleKeys); }### Answer:
@Test public void load_rules_key_based() throws Exception { ruleMetadataLoader.addRulesByRuleKey(newRepository, Arrays.asList("S110", "S100")); newRepository.done(); RulesDefinition.Repository repository = context.repository(RULE_REPOSITORY_KEY); RulesDefinition.Rule ruleS110 = repository.rule("S110"); assertThat(ruleS110).isNotNull(); assertThat(ruleS110.name()).isEqualTo("Inheritance tree of classes should not be too deep"); assertThat(ruleS110.htmlDescription()).isEqualTo("<p>description S110</p>"); RulesDefinition.Rule ruleS100 = repository.rule("S100"); assertThat(ruleS100).isNotNull(); assertThat(ruleS100.name()).isEqualTo("Function names should comply with a naming convention"); assertThat(ruleS100.htmlDescription()).isEqualTo("<p>description S100</p>"); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.