method2testcases
stringlengths 118
3.08k
|
|---|
### 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:
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 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 { @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:
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 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:
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:
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:
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:
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:
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:
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:
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:
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>"); } |
### Question:
SafetyFactory { @Deprecated public static XMLInputFactory createXMLInputFactory() { return SafeStaxParserFactory.createXMLInputFactory(); } private SafetyFactory(); @Deprecated static XMLInputFactory createXMLInputFactory(); @Deprecated static DocumentBuilder createDocumentBuilder(boolean namespaceAware); }### Answer:
@Test public void test_createXMLInputFactory() { assertThat(SafetyFactory.createXMLInputFactory()).isNotNull(); } |
### Question:
RuleMetadataLoader { static String[] getStringArray(Map<String, Object> map, String propertyName) { Object propertyValue = map.get(propertyName); if (!(propertyValue instanceof List)) { throw new IllegalStateException(String.format(INVALID_PROPERTY_MESSAGE, propertyName)); } return ((List<String>) propertyValue).toArray(new String[0]); } 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 getStringArray() throws Exception { Map<String, Object> map = Collections.singletonMap("key", Arrays.asList("x", "y")); assertThat(RuleMetadataLoader.getStringArray(map, "key")).containsExactly("x", "y"); }
@Test(expected = IllegalStateException.class) public void getStringArray_with_invalid_type() throws Exception { Map<String, Object> map = Collections.singletonMap("key", "x"); RuleMetadataLoader.getStringArray(map, "key"); }
@Test(expected = IllegalStateException.class) public void getStringArray_without_property() throws Exception { RuleMetadataLoader.getStringArray(Collections.emptyMap(), "key"); } |
### Question:
SafetyFactory { @Deprecated public static DocumentBuilder createDocumentBuilder(boolean namespaceAware) { return SafeDomParserFactory.createDocumentBuilder(namespaceAware); } private SafetyFactory(); @Deprecated static XMLInputFactory createXMLInputFactory(); @Deprecated static DocumentBuilder createDocumentBuilder(boolean namespaceAware); }### Answer:
@Test public void test_createDocumentBuilder() { assertThat(SafetyFactory.createDocumentBuilder(true)).isNotNull(); assertThat(SafetyFactory.createDocumentBuilder(false)).isNotNull(); } |
### Question:
Resources { static String toString(String path, Charset charset) throws IOException { try (InputStream input = Resources.class.getClassLoader().getResourceAsStream(path)) { if (input == null) { throw new IOException("Resource not found in the classpath: " + path); } ByteArrayOutputStream out = new ByteArrayOutputStream(); byte[] buffer = new byte[BUFFER_SIZE]; for (int read = input.read(buffer); read != -1; read = input.read(buffer)) { out.write(buffer, 0, read); } return new String(out.toByteArray(), charset); } } private Resources(); }### Answer:
@Test public void read_resource() throws Exception { assertThat(Resources.toString("org/sonarsource/analyzer/commons/ResourcesTest.txt", UTF_8)).isEqualTo("hello\n"); }
@Test(expected = IOException.class) public void read_invalid_resource() throws Exception { Resources.toString("invalid/path.txt", UTF_8); } |
### Question:
ExternalReportProvider { public static List<File> getReportFiles(SensorContext context, String externalReportsProperty) { boolean externalIssuesSupported = context.getSonarQubeVersion().isGreaterThanOrEqual(Version.create(7, 2)); String[] reportPaths = context.config().getStringArray(externalReportsProperty); if (reportPaths.length == 0) { return Collections.emptyList(); } if (!externalIssuesSupported) { LOG.error("Import of external issues requires SonarQube 7.2 or greater."); return Collections.emptyList(); } List<File> result = new ArrayList<>(); for (String reportPath : reportPaths) { File report = getIOFile(context.fileSystem().baseDir(), reportPath); result.add(report); } return result; } private ExternalReportProvider(); static List<File> getReportFiles(SensorContext context, String externalReportsProperty); }### Answer:
@Test public void test_return_empty_when_no_value() throws Exception { SensorContextTester context = SensorContextTester.create(new File(".")); List<File> reportFiles = ExternalReportProvider.getReportFiles(context, EXTERNAL_REPORTS_PROPERTY); assertThat(reportFiles).isEmpty(); assertThat(logTester.logs()).isEmpty(); }
@Test public void test_resolve_abs_and_relative() throws Exception { SensorContextTester context = SensorContextTester.create(new File("src/test/resources")); context.settings().setProperty(EXTERNAL_REPORTS_PROPERTY, "foo.out, " + new File("src/test/resources/bar.out").getAbsolutePath()); List<File> reportFiles = ExternalReportProvider.getReportFiles(context, EXTERNAL_REPORTS_PROPERTY); assertThat(reportFiles).hasSize(2); assertThat(reportFiles.get(0).getAbsolutePath()).isEqualTo(new File("src/test/resources/foo.out").getAbsolutePath()); assertThat(reportFiles.get(1).getAbsolutePath()).isEqualTo(new File("src/test/resources/bar.out").getAbsolutePath()); assertThat(logTester.logs()).isEmpty(); } |
### Question:
ContainsDetector extends Detector { @Override public int scan(String line) { String lineWithoutWhitespaces = StringUtils.deleteWhitespace(line); int matchers = 0; for (String str : strs) { matchers += StringUtils.countMatches(lineWithoutWhitespaces, str); } return matchers; } ContainsDetector(double probability, String... strs); @Override int scan(String line); }### Answer:
@Test public void scan() { ContainsDetector detector = new ContainsDetector(0.3, "++", "for("); assertThat(detector.scan("for (int i =0; i++; i<4) {")).isEqualTo(2); assertThat(detector.scan("String name;")).isZero(); } |
### Question:
EndWithDetector extends Detector { @Override public int scan(String line) { for (int index = line.length() - 1; index >= 0; index--) { char character = line.charAt(index); for (char endOfLine : endOfLines) { if (character == endOfLine) { return 1; } } if (!Character.isWhitespace(character) && character != '*' && character != '/') { return 0; } } return 0; } EndWithDetector(double probability, char... endOfLines); @Override int scan(String line); }### Answer:
@Test public void scan() { EndWithDetector detector = new EndWithDetector(0.3, '}'); assertThat(detector.scan(" return true; }")).isOne(); assertThat(detector.scan("} catch(NullPointerException e) {")).isZero(); assertThat(detector.scan("} ")).isOne(); assertThat(detector.scan("}*")).isOne(); assertThat(detector.scan("}/")).isOne(); assertThat(detector.scan("")).isZero(); } |
### Question:
CamelCaseDetector extends Detector { @Override public int scan(String line) { char previousChar = ' '; char indexChar; for (int i = 0; i < line.length(); i++) { indexChar = line.charAt(i); if (isLowerCaseThenUpperCase(previousChar, indexChar)) { return 1; } previousChar = indexChar; } return 0; } CamelCaseDetector(double probability); @Override int scan(String line); }### Answer:
@Test public void scan() { CamelCaseDetector detector = new CamelCaseDetector(0.3); assertThat(detector.scan("isDog() or isCat()")).isOne(); assertThat(detector.scan("String name;")).isZero(); } |
### Question:
XmlFile { @CheckForNull public static Node nodeAttribute(Node node, String attribute) { NamedNodeMap attributes = node.getAttributes(); if (attributes == null) { return null; } return attributes.getNamedItem(attribute); } private XmlFile(InputFile inputFile); private XmlFile(String str); static XmlFile create(InputFile inputFile); static XmlFile create(String str); @Nullable InputFile getInputFile(); String getContents(); Charset getCharset(); Document getDocument(); Document getNamespaceAwareDocument(); Document getNamespaceUnawareDocument(); Optional<PrologElement> getPrologElement(); static XmlTextRange startLocation(CDATASection node); static XmlTextRange endLocation(CDATASection node); static XmlTextRange startLocation(Element node); static XmlTextRange endLocation(Element node); static XmlTextRange nameLocation(Element node); static XmlTextRange attributeNameLocation(Attr node); static XmlTextRange attributeValueLocation(Attr node); static XmlTextRange nodeLocation(Node node); static Optional<XmlTextRange> getRange(Node node, Location location); static List<Node> children(Node node); static List<Node> asList(@Nullable NodeList nodeList); @CheckForNull static Node nodeAttribute(Node node, String attribute); }### Answer:
@Test public void testNodeAttribute() throws Exception { XmlFile xmlFile = XmlFile.create( "<a attr='foo'>\n" + " <!-- comment -->\n" + " <b>world</b>\n" + "</a>"); Node aNode = xmlFile.getDocument().getFirstChild(); assertThat(XmlFile.nodeAttribute(aNode, "attr")).isNotNull(); assertThat(XmlFile.nodeAttribute(aNode, "unknown")).isNull(); Node commentNode = aNode.getFirstChild(); assertThat(XmlFile.nodeAttribute(commentNode, "unknown")).isNull(); } |
### Question:
KeywordsDetector extends Detector { @Override public int scan(String line) { int matchers = 0; if (toUpperCase) { line = line.toUpperCase(Locale.getDefault()); } StringTokenizer tokenizer = new StringTokenizer(line, " \t(),{}"); while (tokenizer.hasMoreTokens()) { String word = tokenizer.nextToken(); if (keywords.contains(word)) { matchers++; } } return matchers; } KeywordsDetector(double probability, String... keywords); KeywordsDetector(double probability, boolean toUpperCase, String... keywords); @Override int scan(String line); }### Answer:
@Test public void scan() { KeywordsDetector detector = new KeywordsDetector(0.3, "public", "static"); assertThat(detector.scan("public static void main")).isEqualTo(2); assertThat(detector.scan("private(static} String name;")).isOne(); assertThat(detector.scan("publicstatic")).isZero(); assertThat(detector.scan("i++;")).isZero(); detector = new KeywordsDetector(0.3, true, "PUBLIC"); assertThat(detector.scan("Public static pubLIC")).isEqualTo(2); } |
### Question:
CodeRecognizer { public final boolean isLineOfCode(String line) { return recognition(line) - threshold > 0; } CodeRecognizer(double threshold, LanguageFootprint language); final double recognition(String line); final List<String> extractCodeLines(List<String> lines); final boolean isLineOfCode(String line); }### Answer:
@Test public void isLineOfCode() { CodeRecognizer cr = new CodeRecognizer(0.8, new FakeFootprint()); assertThat(cr.isLineOfCode("}")).isTrue(); assertThat(cr.isLineOfCode("squid")).isFalse(); } |
### Question:
CodeRecognizer { public final List<String> extractCodeLines(List<String> lines) { List<String> codeLines = new ArrayList<>(); for (String line : lines) { if (recognition(line) >= threshold) { codeLines.add(line); } } return codeLines; } CodeRecognizer(double threshold, LanguageFootprint language); final double recognition(String line); final List<String> extractCodeLines(List<String> lines); final boolean isLineOfCode(String line); }### Answer:
@Test public void extractCodeLines() { CodeRecognizer cr = new CodeRecognizer(0.8, new FakeFootprint()); assertThat(cr.extractCodeLines(Arrays.asList("{", "squid"))).containsOnly("{"); } |
### Question:
ProgressReport implements Runnable { public synchronized void cancel() { thread.interrupt(); join(); } ProgressReport(String threadName, long period, Logger logger, String adjective); ProgressReport(String threadName, long period, String adjective); ProgressReport(String threadName, long period); @Override void run(); synchronized void start(Iterable<String> filenames); synchronized void nextFile(); synchronized void stop(); synchronized void cancel(); }### Answer:
@Test(timeout = 5000) public void testCancel() throws InterruptedException { Logger logger = mock(Logger.class); ProgressReport report = new ProgressReport(ProgressReport.class.getName(), 100, logger, "analyzed"); report.start(Arrays.asList("foo.java")); waitForMessage(logger); report.cancel(); } |
### Question:
JsonParser { Map<String, Object> parse(String data) { try { return (Map<String, Object>) parser.parse(data); } catch (ParseException e) { throw new IllegalArgumentException("Could not parse JSON", e); } } }### Answer:
@Test public void parse() throws Exception { JsonParser parser = new JsonParser(); Map<String, Object> map = parser.parse("{ \"name\" : \"Paul\" }"); Object name = map.get("name"); assertThat(name).isEqualTo("Paul"); }
@Test(expected = IllegalArgumentException.class) public void invalid_json() { new JsonParser().parse("{{}"); } |
### Question:
ReflectionResource { @DELETE @Path("/{id}") public Response deleteReflection(@PathParam("id") String id) { reflectionServiceHelper.removeReflection(id); return Response.ok().build(); } @Inject ReflectionResource(ReflectionServiceHelper reflectionServiceHelper, CatalogServiceHelper catalogServiceHelper); @GET @Path("/{id}") Reflection getReflection(@PathParam("id") String id); @POST Reflection createReflection(Reflection reflection); @PUT @Path("/{id}") Reflection editReflection(@PathParam("id") String id, Reflection reflection); @DELETE @Path("/{id}") Response deleteReflection(@PathParam("id") String id); }### Answer:
@Test public void testDeleteReflection() { Reflection newReflection = createReflection(); Reflection response = expectSuccess(getBuilder(getPublicAPI(3).path(REFLECTIONS_PATH)).buildPost(Entity.entity(newReflection, JSON)), Reflection.class); expectSuccess(getBuilder(getPublicAPI(3).path(REFLECTIONS_PATH).path(response.getId())).buildDelete()); assertFalse(newReflectionServiceHelper().getReflectionById(response.getId()).isPresent()); } |
### Question:
SourceResource { @GET @RolesAllowed({"admin", "user"}) public ResponseList<Source> getSources() { final ResponseList<Source> sources = new ResponseList<>(); final List<SourceConfig> sourceConfigs = sourceService.getSources(); for (SourceConfig sourceConfig : sourceConfigs) { Source source = fromSourceConfig(sourceConfig); sources.add(source); } return sources; } @Inject SourceResource(SourceService sourceService, SabotContext sabotContext); @GET @RolesAllowed({"admin", "user"}) ResponseList<Source> getSources(); @POST @RolesAllowed({"admin"}) SourceDeprecated addSource(SourceDeprecated source); @GET @RolesAllowed({"admin", "user"}) @Path("/{id}") SourceDeprecated getSource(@PathParam("id") String id); @PUT @RolesAllowed({"admin"}) @Path("/{id}") SourceDeprecated updateSource(@PathParam("id") String id, SourceDeprecated source); @DELETE @RolesAllowed("admin") @Path("/{id}") Response deleteSource(@PathParam("id") String id); @GET @RolesAllowed("admin") @Path("/type") ResponseList<SourceTypeTemplate> getSourceTypes(); @GET @RolesAllowed("admin") @Path("/type/{name}") SourceTypeTemplate getSourceByType(@PathParam("name") String name); }### Answer:
@Test public void testListSources() throws Exception { ResponseList<SourceResource.SourceDeprecated> sources = expectSuccess(getBuilder(getPublicAPI(3).path(SOURCES_PATH)).buildGet(), new GenericType<ResponseList<SourceResource.SourceDeprecated>>() {}); assertEquals(sources.getData().size(), newSourceService().getSources().size()); } |
### Question:
SourceResource { @POST @RolesAllowed({"admin"}) public SourceDeprecated addSource(SourceDeprecated source) { try { SourceConfig newSourceConfig = sourceService.createSource(source.toSourceConfig()); return fromSourceConfig(newSourceConfig); } catch (NamespaceException | ExecutionSetupException e) { throw new ServerErrorException(e); } } @Inject SourceResource(SourceService sourceService, SabotContext sabotContext); @GET @RolesAllowed({"admin", "user"}) ResponseList<Source> getSources(); @POST @RolesAllowed({"admin"}) SourceDeprecated addSource(SourceDeprecated source); @GET @RolesAllowed({"admin", "user"}) @Path("/{id}") SourceDeprecated getSource(@PathParam("id") String id); @PUT @RolesAllowed({"admin"}) @Path("/{id}") SourceDeprecated updateSource(@PathParam("id") String id, SourceDeprecated source); @DELETE @RolesAllowed("admin") @Path("/{id}") Response deleteSource(@PathParam("id") String id); @GET @RolesAllowed("admin") @Path("/type") ResponseList<SourceTypeTemplate> getSourceTypes(); @GET @RolesAllowed("admin") @Path("/type/{name}") SourceTypeTemplate getSourceByType(@PathParam("name") String name); }### Answer:
@Test public void testAddSource() throws Exception { SourceResource.SourceDeprecated newSource = new SourceResource.SourceDeprecated(); newSource.setName("Foopy"); newSource.setType("NAS"); NASConf config = new NASConf(); config.path = "/"; newSource.setConfig(config); SourceResource.SourceDeprecated source = expectSuccess(getBuilder(getPublicAPI(3).path(SOURCES_PATH)).buildPost(Entity.entity(newSource, JSON)), SourceResource.SourceDeprecated.class); assertEquals(source.getName(), newSource.getName()); assertNotNull(source.getState()); deleteSource(source.getName()); } |
### Question:
SourceResource { @GET @RolesAllowed({"admin", "user"}) @Path("/{id}") public SourceDeprecated getSource(@PathParam("id") String id) throws NamespaceException { SourceConfig sourceConfig = sourceService.getById(id); return fromSourceConfig(sourceConfig); } @Inject SourceResource(SourceService sourceService, SabotContext sabotContext); @GET @RolesAllowed({"admin", "user"}) ResponseList<Source> getSources(); @POST @RolesAllowed({"admin"}) SourceDeprecated addSource(SourceDeprecated source); @GET @RolesAllowed({"admin", "user"}) @Path("/{id}") SourceDeprecated getSource(@PathParam("id") String id); @PUT @RolesAllowed({"admin"}) @Path("/{id}") SourceDeprecated updateSource(@PathParam("id") String id, SourceDeprecated source); @DELETE @RolesAllowed("admin") @Path("/{id}") Response deleteSource(@PathParam("id") String id); @GET @RolesAllowed("admin") @Path("/type") ResponseList<SourceTypeTemplate> getSourceTypes(); @GET @RolesAllowed("admin") @Path("/type/{name}") SourceTypeTemplate getSourceByType(@PathParam("name") String name); }### Answer:
@Test public void testGetSource() throws Exception { SourceConfig sourceConfig = new SourceConfig(); sourceConfig.setName("Foopy4"); NASConf nasConfig = new NASConf(); sourceConfig.setType(nasConfig.getType()); nasConfig.path = "/"; sourceConfig.setConfig(nasConfig.toBytesString()); SourceConfig createdSourceConfig = newSourceService().registerSourceWithRuntime(sourceConfig); SourceResource.SourceDeprecated source = expectSuccess(getBuilder(getPublicAPI(3).path(SOURCES_PATH).path(createdSourceConfig.getId().getId())).buildGet(), SourceResource.SourceDeprecated.class); assertEquals(source.getName(), sourceConfig.getName()); assertNotNull(source.getState()); } |
### Question:
SourceResource { @VisibleForTesting protected SourceDeprecated fromSourceConfig(SourceConfig sourceConfig) { return new SourceDeprecated(sourceService.fromSourceConfig(sourceConfig)); } @Inject SourceResource(SourceService sourceService, SabotContext sabotContext); @GET @RolesAllowed({"admin", "user"}) ResponseList<Source> getSources(); @POST @RolesAllowed({"admin"}) SourceDeprecated addSource(SourceDeprecated source); @GET @RolesAllowed({"admin", "user"}) @Path("/{id}") SourceDeprecated getSource(@PathParam("id") String id); @PUT @RolesAllowed({"admin"}) @Path("/{id}") SourceDeprecated updateSource(@PathParam("id") String id, SourceDeprecated source); @DELETE @RolesAllowed("admin") @Path("/{id}") Response deleteSource(@PathParam("id") String id); @GET @RolesAllowed("admin") @Path("/type") ResponseList<SourceTypeTemplate> getSourceTypes(); @GET @RolesAllowed("admin") @Path("/type/{name}") SourceTypeTemplate getSourceByType(@PathParam("name") String name); }### Answer:
@Test public void testRemovingSensitiveFields() throws Exception { SourceConfig config = new SourceConfig(); config.setName("Foopy"); config.setId(new EntityId("id")); config.setTag("0"); config.setAccelerationGracePeriod(0L); config.setAccelerationRefreshPeriod(0L); APrivateSource priv = new APrivateSource(); priv.password = "hello"; config.setConnectionConf(priv); SourceResource sourceResource = new SourceResource(newSourceService(), null); SourceResource.SourceDeprecated source = sourceResource.fromSourceConfig(config); APrivateSource newConfig = (APrivateSource) source.getConfig(); assertEquals(newConfig.password, ConnectionConf.USE_EXISTING_SECRET_VALUE); } |
### Question:
UserResource { @RolesAllowed({"admin"}) @POST public User createUser(User user) throws IOException { final com.dremio.service.users.User userConfig = UserResource.addUser(of(user, Optional.empty()), user.getPassword(), userGroupService, namespaceService); return User.fromUser(userConfig); } @Inject UserResource(UserService userGroupService,
NamespaceService namespaceService,
@Context SecurityContext securityContext); @GET @Path("/{id}") User getUser(@PathParam("id") String id); @RolesAllowed({"admin"}) @POST User createUser(User user); static com.dremio.service.users.User addUser(com.dremio.service.users.User newUser, String password, UserService userService,
NamespaceService namespaceService); @RolesAllowed({"admin", "user"}) @PUT @Path("/{id}") User updateUser(User user, @PathParam("id") String id); @GET @Path("/by-name/{name}") User getUserByName(@PathParam("name") String name); }### Answer:
@Test public void testCreateUser() throws Exception { UserInfoRequest userInfo = new UserInfoRequest(null, "test_new_user", "test", "new user", "[email protected]", "0", "123some_password", null); User savedUser = expectSuccess(getBuilder(getPublicAPI(3).path(USER_PATH)) .buildPost(Entity.json(userInfo)), User.class); assertNotNull(savedUser.getId()); assertEquals(savedUser.getName(), userInfo.getName()); assertEquals(savedUser.getFirstName(), userInfo.getFirstName()); assertEquals(savedUser.getLastName(), userInfo.getLastName()); assertEquals(savedUser.getEmail(), userInfo.getEmail()); assertNull("Password should not be sent to a data consumer", savedUser.getPassword()); assertNotNull(savedUser.getTag()); final UserService userService = l(UserService.class); userService.deleteUser(savedUser.getName(), savedUser.getTag()); } |
### Question:
UserResource { @GET @Path("/by-name/{name}") public User getUserByName(@PathParam("name") String name) throws UserNotFoundException { return User.fromUser(userGroupService.getUser(name)); } @Inject UserResource(UserService userGroupService,
NamespaceService namespaceService,
@Context SecurityContext securityContext); @GET @Path("/{id}") User getUser(@PathParam("id") String id); @RolesAllowed({"admin"}) @POST User createUser(User user); static com.dremio.service.users.User addUser(com.dremio.service.users.User newUser, String password, UserService userService,
NamespaceService namespaceService); @RolesAllowed({"admin", "user"}) @PUT @Path("/{id}") User updateUser(User user, @PathParam("id") String id); @GET @Path("/by-name/{name}") User getUserByName(@PathParam("name") String name); }### Answer:
@Test public void testGetUserByName() throws Exception { final UserService userService = l(UserService.class); User user = expectSuccess(getBuilder(getPublicAPI(3).path(USER_PATH).path("by-name").path(createdUser.getUserName())).buildGet(), User.class); assertEquals(user.getId(), createdUser.getUID().getId()); assertEquals(user.getName(), createdUser.getUserName()); } |
### Question:
UserStats { public String getEdition() { return edition; } String getEdition(); List<Map<String, Object>> getUserStatsByDate(); List<Map<String, Object>> getUserStatsByWeek(); List<Map<String, Object>> getUserStatsByMonth(); }### Answer:
@Test public void testGetEdition() { UserStats.Builder stats = new UserStats.Builder(); stats.setEdition("oss"); String expected = "dremio-oss-" + DremioVersionInfo.getVersion(); assertEquals(expected, stats.build().getEdition()); } |
### Question:
UserStats { public List<Map<String, Object>> getUserStatsByMonth() { return userStatsByMonth; } String getEdition(); List<Map<String, Object>> getUserStatsByDate(); List<Map<String, Object>> getUserStatsByWeek(); List<Map<String, Object>> getUserStatsByMonth(); }### Answer:
@Test public void testGetStatsByMonth() { UserStats.Builder statsBuilder = new UserStats.Builder(); LocalDate now = LocalDate.now(); statsBuilder.addUserStat(toEpochMillis(now.minusMonths(1)), "UI", "testuser1"); statsBuilder.addUserStat(toEpochMillis(now.minusMonths(1)), "UI", "testuser1"); statsBuilder.addUserStat(toEpochMillis(now.minusMonths(1)), "ODBC", "testuser1"); statsBuilder.addUserStat(toEpochMillis(now.minusMonths(1)), "ODBC", "testuser2"); statsBuilder.addUserStat(toEpochMillis(now), "UI", "testuser1"); statsBuilder.addUserStat(toEpochMillis(now), "UI", "testuser1"); statsBuilder.addUserStat(toEpochMillis(now), "ODBC", "testuser1"); statsBuilder.addUserStat(toEpochMillis(now), "ODBC", "testuser2"); List<Map<String, Object>> statsByDate = statsBuilder.build().getUserStatsByMonth(); assertEquals(2, statsByDate.size()); Map<String, Object> firstDateEntry = fetchDateEntry("month", getMonthStartDate(now.minusMonths(1)).toString(), statsByDate); assertEquals(1, firstDateEntry.get("UI")); assertEquals(2, firstDateEntry.get("ODBC")); assertEquals(2, firstDateEntry.get("total")); Map<String, Object> secondDateEntry = fetchDateEntry("month", getMonthStartDate(now).toString(), statsByDate); assertEquals(1, secondDateEntry.get("UI")); assertEquals(2, secondDateEntry.get("ODBC")); assertEquals(2, secondDateEntry.get("total")); } |
### Question:
MediaTypeFilter implements ContainerRequestFilter { @Override public void filter(ContainerRequestContext requestContext) throws IOException { final UriInfo info = requestContext.getUriInfo(); MultivaluedMap<String, String> parameters = info.getQueryParameters(); String format = parameters.getFirst("format"); if (format == null) { return; } requestContext.getHeaders().putSingle(HttpHeaders.ACCEPT, format); } @Override void filter(ContainerRequestContext requestContext); }### Answer:
@Test public void testHeaderChange() throws IOException { MediaTypeFilter filter = new MediaTypeFilter(); ContainerRequest request = ContainerRequestBuilder.from("http: filter.filter(request); assertEquals(1, request.getAcceptableMediaTypes().size()); assertEquals(new AcceptableMediaType("unit", "test"), request.getAcceptableMediaTypes().get(0)); }
@Test public void testHeaderIsUntouched() throws IOException { MediaTypeFilter filter = new MediaTypeFilter(); ContainerRequest request = ContainerRequestBuilder.from("http: filter.filter(request); assertEquals(1, request.getAcceptableMediaTypes().size()); assertEquals(new AcceptableMediaType("random", "media"), request.getAcceptableMediaTypes().get(0)); } |
### Question:
ClasspathHealthMonitor implements LiveHealthMonitor { @Override public boolean isHealthy() { logger.debug("Checking jars {}", necessaryJarFoldersSet.size()); for(String jarFolderPath : necessaryJarFoldersSet) { File jarFolder = new File(jarFolderPath); boolean folderAccessible = false; try { folderAccessible = Files.isExecutable(jarFolder.toPath()); } catch (SecurityException se) { logger.error("SecurityException while checking folder: {}", jarFolderPath, se); } if (!folderAccessible) { logger.error("Jar: {} does not exist or it is not readable!", jarFolderPath); return false; } } logger.debug("All necessary jars exist and are readable."); return true; } ClasspathHealthMonitor(); ClasspathHealthMonitor(Set<String> classpath); @Override boolean isHealthy(); }### Answer:
@Test public void testIsHealthy() { assertTrue(classpathHealthMonitor.isHealthy()); new File(secondJarFolder).setExecutable(false); assertFalse(classpathHealthMonitor.isHealthy()); new File(secondJarFolder).setExecutable(true); assertTrue(classpathHealthMonitor.isHealthy()); new File(secondJarFolder).delete(); assertFalse(classpathHealthMonitor.isHealthy()); } |
### Question:
JSONJobDataFilter implements ContainerResponseFilter { @Override public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) throws IOException { if (!APPLICATION_JSON_TYPE.equals(responseContext.getMediaType()) || !WebServer.X_DREMIO_JOB_DATA_NUMBERS_AS_STRINGS_SUPPORTED_VALUE .equals(requestContext.getHeaderString(WebServer.X_DREMIO_JOB_DATA_NUMBERS_AS_STRINGS))) { return; } ObjectWriterInjector.set(new NumberAsStringWriter(ObjectWriterInjector.getAndClear())); } @Override void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext); }### Answer:
@Test public void testJSONGeneratorUntouched() throws IOException { JSONJobDataFilter filter = new JSONJobDataFilter(); ContainerRequestBuilder request = ContainerRequestBuilder.from("http: if (testData.getHeaderKey() != null) { request.header(testData.getHeaderKey(), testData.getHeaderValue()); } ContainerResponse response = new ContainerResponse(request.build(), Response.ok().type(testData.getMediaType()).build()); filter.filter(request.build(), response); ObjectWriterModifier modifier = ObjectWriterInjector.get(); if (testData.isExpectedToBeTouched()) { assertNotNull(modifier); ObjectWriter writer = mock(ObjectWriter.class); modifier.modify(mock(JsonEndpointConfig.class), new MultivaluedHashMap<String, Object>(), new Object(), writer, mock(JsonGenerator.class)); verify(writer).withAttribute(DataJsonOutput.DREMIO_JOB_DATA_NUMBERS_AS_STRINGS_ATTRIBUTE, true); } else { assertNull(modifier); } } |
### Question:
JSONPrettyPrintFilter implements ContainerResponseFilter { @Override public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) throws IOException { UriInfo info = requestContext.getUriInfo(); if (!info.getQueryParameters().containsKey("pretty")) { return; } ObjectWriterInjector.set(new PrettyPrintWriter(ObjectWriterInjector.getAndClear())); } @Override void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext); }### Answer:
@Test public void testJSONGeneratorConfigured() throws IOException { JSONPrettyPrintFilter filter = new JSONPrettyPrintFilter(); ContainerRequest request = ContainerRequestBuilder.from("http: ContainerResponse response = new ContainerResponse(request, Response.ok().build()); filter.filter(request, response); ObjectWriterModifier modifier = ObjectWriterInjector.get(); assertNotNull(modifier); JsonGenerator g = mock(JsonGenerator.class); modifier.modify(mock(JsonEndpointConfig.class), new MultivaluedHashMap<String, Object>(), new Object(), mock(ObjectWriter.class), g); verify(g).useDefaultPrettyPrinter(); }
@Test public void testJSONGeneratorUntouched() throws IOException { JSONPrettyPrintFilter filter = new JSONPrettyPrintFilter(); ContainerRequest request = ContainerRequestBuilder.from("http: ContainerResponse response = new ContainerResponse(request, Response.ok().build()); filter.filter(request, response); ObjectWriterModifier modifier = ObjectWriterInjector.get(); assertNull(modifier); } |
### Question:
AttemptsHelper { public Long getPlanningTime() { return getDuration(State.PLANNING); } AttemptsHelper(JobAttempt jobAttempt); boolean hasStateDurations(); static long getCommandPoolWaitTime(JobAttempt jobAttempt); static long getLegacyEnqueuedTime(JobAttempt jobAttempt); static long getPoolWaitTime(JobAttempt jobAttempt); static long getLegacyPlanningTime(JobAttempt jobAttempt); static long getLegacyExecutionTime(JobAttempt jobAttempt); Long getPendingTime(); Long getMetadataRetrievalTime(); Long getPlanningTime(); Long getQueuedTime(); Long getEngineStartTime(); Long getExecutionPlanningTime(); Long getStartingTime(); Long getRunningTime(); Long getTotalTime(); }### Answer:
@Test public void testGetPlanningTime() { final ResourceSchedulingInfo schedulingInfo = new ResourceSchedulingInfo() .setResourceSchedulingStart(System.currentTimeMillis() - TimeUnit.HOURS.toMillis(3)) .setResourceSchedulingEnd(0L); final JobInfo info = new JobInfo() .setResourceSchedulingInfo(schedulingInfo); final JobAttempt attempt = new JobAttempt() .setInfo(info) .setState(JobState.ENQUEUED) .setDetails(new JobDetails()); assertEquals(0L, AttemptsHelper.getLegacyPlanningTime(attempt)); }
@Test public void testPlanningTime() { Preconditions.checkNotNull(attemptsHelper.getPlanningTime()); assertTrue(1L == attemptsHelper.getPlanningTime()); } |
### Question:
AttemptsHelper { public static long getLegacyExecutionTime(JobAttempt jobAttempt) { final JobInfo jobInfo = jobAttempt.getInfo(); if (jobInfo == null) { return 0; } final JobDetails jobDetails = jobAttempt.getDetails(); if (jobDetails == null) { return 0; } final long startTime = Optional.ofNullable(jobInfo.getStartTime()).orElse(0L); final long finishTime = Optional.ofNullable(jobInfo.getFinishTime()).orElse(startTime); final long planningScheduling = Optional.ofNullable(jobDetails.getTimeSpentInPlanning()).orElse(0L); return finishTime - startTime - planningScheduling; } AttemptsHelper(JobAttempt jobAttempt); boolean hasStateDurations(); static long getCommandPoolWaitTime(JobAttempt jobAttempt); static long getLegacyEnqueuedTime(JobAttempt jobAttempt); static long getPoolWaitTime(JobAttempt jobAttempt); static long getLegacyPlanningTime(JobAttempt jobAttempt); static long getLegacyExecutionTime(JobAttempt jobAttempt); Long getPendingTime(); Long getMetadataRetrievalTime(); Long getPlanningTime(); Long getQueuedTime(); Long getEngineStartTime(); Long getExecutionPlanningTime(); Long getStartingTime(); Long getRunningTime(); Long getTotalTime(); }### Answer:
@Test public void testGetExecutionTime() { final ResourceSchedulingInfo schedulingInfo = new ResourceSchedulingInfo() .setResourceSchedulingStart(System.currentTimeMillis() - TimeUnit.HOURS.toMillis(3)) .setResourceSchedulingEnd(0L); final JobInfo info = new JobInfo() .setResourceSchedulingInfo(schedulingInfo); final JobAttempt attempt = new JobAttempt() .setInfo(info) .setState(JobState.ENQUEUED) .setDetails(new JobDetails()); assertEquals(0L, AttemptsHelper.getLegacyExecutionTime(attempt)); } |
### Question:
AttemptsHelper { public Long getPendingTime() { return getDuration(State.PENDING); } AttemptsHelper(JobAttempt jobAttempt); boolean hasStateDurations(); static long getCommandPoolWaitTime(JobAttempt jobAttempt); static long getLegacyEnqueuedTime(JobAttempt jobAttempt); static long getPoolWaitTime(JobAttempt jobAttempt); static long getLegacyPlanningTime(JobAttempt jobAttempt); static long getLegacyExecutionTime(JobAttempt jobAttempt); Long getPendingTime(); Long getMetadataRetrievalTime(); Long getPlanningTime(); Long getQueuedTime(); Long getEngineStartTime(); Long getExecutionPlanningTime(); Long getStartingTime(); Long getRunningTime(); Long getTotalTime(); }### Answer:
@Test public void testGetPendingTime() { Preconditions.checkNotNull(attemptsHelper.getPendingTime()); assertTrue(1L == attemptsHelper.getPendingTime()); } |
### Question:
AttemptsHelper { public Long getMetadataRetrievalTime() { return getDuration(State.METADATA_RETRIEVAL); } AttemptsHelper(JobAttempt jobAttempt); boolean hasStateDurations(); static long getCommandPoolWaitTime(JobAttempt jobAttempt); static long getLegacyEnqueuedTime(JobAttempt jobAttempt); static long getPoolWaitTime(JobAttempt jobAttempt); static long getLegacyPlanningTime(JobAttempt jobAttempt); static long getLegacyExecutionTime(JobAttempt jobAttempt); Long getPendingTime(); Long getMetadataRetrievalTime(); Long getPlanningTime(); Long getQueuedTime(); Long getEngineStartTime(); Long getExecutionPlanningTime(); Long getStartingTime(); Long getRunningTime(); Long getTotalTime(); }### Answer:
@Test public void testGetMetadataRetrievalTime() { Preconditions.checkNotNull(attemptsHelper.getMetadataRetrievalTime()); assertTrue(1L == attemptsHelper.getMetadataRetrievalTime()); } |
### Question:
AttemptsHelper { public Long getEngineStartTime() { return getDuration(State.ENGINE_START); } AttemptsHelper(JobAttempt jobAttempt); boolean hasStateDurations(); static long getCommandPoolWaitTime(JobAttempt jobAttempt); static long getLegacyEnqueuedTime(JobAttempt jobAttempt); static long getPoolWaitTime(JobAttempt jobAttempt); static long getLegacyPlanningTime(JobAttempt jobAttempt); static long getLegacyExecutionTime(JobAttempt jobAttempt); Long getPendingTime(); Long getMetadataRetrievalTime(); Long getPlanningTime(); Long getQueuedTime(); Long getEngineStartTime(); Long getExecutionPlanningTime(); Long getStartingTime(); Long getRunningTime(); Long getTotalTime(); }### Answer:
@Test public void testGetEngineStartTime() { Preconditions.checkNotNull(attemptsHelper.getEngineStartTime()); assertTrue(1L == attemptsHelper.getEngineStartTime()); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.