Java Code Examples for com.google.inject.util.Providers#of()

@Override
public PhoenixTransactionService getTransactionService(Configuration config, ConnectionInfo connInfo, int port) {
    config.setInt(TxConstants.Service.CFG_DATA_TX_BIND_PORT, port);
    int retryTimeOut = config.getInt(TxConstants.Service.CFG_DATA_TX_CLIENT_DISCOVERY_TIMEOUT_SEC, 
            TxConstants.Service.DEFAULT_DATA_TX_CLIENT_DISCOVERY_TIMEOUT_SEC);
    ZKClientService zkClient = ZKClientServices.delegate(
      ZKClients.reWatchOnExpire(
        ZKClients.retryOnFailure(
          ZKClientService.Builder.of(connInfo.getZookeeperConnectionString())
            .setSessionTimeout(config.getInt(HConstants.ZK_SESSION_TIMEOUT,
                    HConstants.DEFAULT_ZK_SESSION_TIMEOUT))
            .build(),
          RetryStrategies.exponentialDelay(500, retryTimeOut, TimeUnit.MILLISECONDS)
        )
      )
    );

    DiscoveryService discovery = new ZKDiscoveryService(zkClient);
    TransactionManager txManager = new TransactionManager(config, new HDFSTransactionStateStorage(config, 
            new SnapshotCodecProvider(config), new TxMetricsCollector()), new TxMetricsCollector());
    TransactionService txService = new TransactionService(config, zkClient, discovery, Providers.of(txManager));
    TephraTransactionService service = new TephraTransactionService(zkClient, txService);
    service.start();
    return service;
}
 

/**
 * Verifies that merging two extracts containing both overlapping and non-overlapping records results in having the overlapping records
 * overwrite the already-present ones and the non-overlapping to be inserted.
 */
@Test
@Parameters(method = "mergeParameters")
public void testMergeTwoExtracts(File controlExtract, File initialDataset, File datasetToMerge) throws IOException {
  // GIVEN

  // ... a control extract (provided)

  // ... a database with some data
  SqlScriptExecutorProvider sqlScriptExecutorProvider = new SqlScriptExecutorProvider(connectionResources.getDataSource(), Providers.of(connectionResources.sqlDialect()));

  log.info("Creating the initial DataSet");

  DataSetConsumer firstDatabaseDataSetConsumer = new SchemaModificationAdapter(new DatabaseDataSetConsumer(connectionResources, sqlScriptExecutorProvider));
  new DataSetConnector(toDataSetProducer(initialDataset), firstDatabaseDataSetConsumer).connect();

  log.info("Initial DataSet creation complete");

  // WHEN

  // ... we merge a datasource having both overlapping and non-overlapping tables and records into it

  DataSetConsumer mergingDatabaseDatasetConsumer = new MergingDatabaseDataSetConsumer(connectionResources, sqlScriptExecutorProvider);
  new DataSetConnector(toDataSetProducer(datasetToMerge), mergingDatabaseDatasetConsumer).connect();

  // ... and we pipe the result into a zip file
  log.info("Creating an XML extract from the merged database tables.");
  File mergedExtractsAsFile = getDatabaseAsFile();
  log.info("Merged XML file creation complete.");

  // THEN

  // ... the resulting dataset matches the control one
  assertThat("the merged dataset should match the control one", mergedExtractsAsFile, sameXmlFileAndLengths(controlExtract));
}
 

@Override
public ModuleType findModule(Location location, ContextPlanner planner, List<String> modulePath) {
    String name = Joiner.on(".").join(modulePath);
    if("test".equals(name)) {
        Provider<Exports> moduleProvider = Providers.of(new TestModule());
        ExportUnitGenerator adapter = new ExportUnitGenerator(planner.getGambitScope());
        return adapter.apply(modulePath, moduleProvider);
    }
    return super.findModule(location, planner, modulePath);
}
 

@BeforeMethod
public void setUp() {
    _dataStore = new InMemoryDataStore(new MetricRegistry());
    _cacheRegistry = mock(CacheRegistry.class);
    _cacheHandle = mock(CacheHandle.class);
    when(_cacheRegistry.register(eq("settings"), any(Cache.class), eq(true))).thenReturn(_cacheHandle);

    _settingsManager = new SettingsManager(Providers.of(_dataStore), "__system:settings",
            "app_global:sys", _cacheRegistry);
}
 

@Before
public void setup() {
  BaseUrlHolder.set("http://baseurl/");

  when(httpServletRequest.getParameter("debug")).thenReturn("false");

  underTest =
      new RaptureWebResourceBundle(applicationVersion, Providers.of(httpServletRequest), Providers.of(stateComponent),
          templateHelper, asList(new UiPluginDescriptorImpl()),
          asList(new ExtJsUiPluginDescriptorImpl("test-1"), new ExtJsUiPluginDescriptorImpl("test-2")));
}
 

@Before
public void setUp() {
  mockServlet = createMock(HttpServlet.class);

  filter =
      new ShiroKerberosPermissiveAuthenticationFilter(Providers.of(createMock(Subject.class)));
}
 

@Before
public void setUp() {
  subject = createMock(Subject.class);
  mockServlet = createMock(HttpServlet.class);

  filter = new ShiroKerberosAuthenticationFilter(Providers.of(subject));
}
 

@Provides
@Singleton
ContextService getContextService(
        Provider<ClusterCoordinator> clusterCoordinator,
        Provider<GroupResourceInformation> resourceInformation,
        Provider<WorkStats> workStats,
        Provider<LegacyKVStoreProvider> kvStoreProvider,
        Provider<FabricService> fabricService,
        Provider<ConduitServer> conduitServer,
        Provider<UserServer> userServer,
        Provider<MaterializationDescriptorProvider> materializationDescriptorProvider,
        Provider<QueryObserverFactory> queryObserverFactory,
        Provider<AccelerationManager> accelerationManager,
        Provider<AccelerationListManager> accelerationListManager,
        Provider<NamespaceService.Factory> namespaceServiceFactory,
        Provider<DatasetListingService> datasetListingService,
        Provider<UserService> userService,
        Provider<CatalogService> catalogService,
        Provider<ConduitProvider> conduitProvider,
        Provider<SpillService> spillService,
        Provider<ConnectionReader> connectionReader,
        Provider<OptionManager> optionManagerProvider,
        Provider<SystemOptionManager> systemOptionManagerProvider,
        Provider<OptionValidatorListing> optionValidatorListingProvider
) {
  return new ContextService(
          bootstrap,
          clusterCoordinator,
          resourceInformation,
          workStats,
          kvStoreProvider,
          fabricService,
          conduitServer,
          userServer,
          materializationDescriptorProvider,
          queryObserverFactory,
          accelerationManager,
          accelerationListManager,
          namespaceServiceFactory,
          datasetListingService,
          userService,
          catalogService,
          conduitProvider,
          Providers.of(null),
          spillService,
          connectionReader,
          CredentialsService::new,
          () -> JobResultInfoProvider.NOOP,
          optionManagerProvider,
          systemOptionManagerProvider,
          Providers.of(null),
          Providers.of(null),
          optionValidatorListingProvider,
          allRoles
  );
}
 

@Override
public TableLoaderBuilder withDialect(SqlDialect sqlDialect) {
  this.sqlDialect = Providers.of(sqlDialect);
  return this;
}
 

/**
 * @param dataSource The database connection source to use
 * @param sqlDialect The dialect to use for the dataSource
 */
public SqlScriptExecutorProvider(final DataSource dataSource, SqlDialect sqlDialect) {
  super();
  this.dataSource = dataSource;
  this.sqlDialect = Providers.<SqlDialect>of(sqlDialect);
}
 

/**
 * Tests that blob fields are added to the the prepared insert statement in correct decoded form.
 *
 * @throws SQLException not really thrown
 */
@Test
public void testBlobInsertion() throws SQLException {

  // Mock all the resources - we're only interested in the PreparedStatement
  // for this test.
  final ConnectionResources connectionResources = Mockito.mock(ConnectionResources.class);
  final DataSource dataSource = Mockito.mock(DataSource.class);
  final Connection connection = Mockito.mock(Connection.class);
  final SqlDialect dialect = Mockito.mock(SqlDialect.class);
  final PreparedStatement statement = Mockito.mock(PreparedStatement.class);
  final java.sql.Blob blob = Mockito.mock(java.sql.Blob.class);
  Mockito.when(statement.getConnection()).thenReturn(connection);
  Mockito.when(connection.createBlob()).thenReturn(blob);
  Mockito.when(blob.setBytes(eq(1L), any(byte[].class))).thenAnswer(invocation -> ((byte[]) invocation.getArguments()[1]).length);
  Mockito.when(connectionResources.getDataSource()).thenReturn(dataSource);
  Mockito.when(dataSource.getConnection()).thenReturn(connection);
  Mockito.when(connectionResources.sqlDialect()).thenReturn(dialect);
  Mockito.when(dialect.convertStatementToSQL(Mockito.any(InsertStatement.class), Mockito.any(Schema.class))).thenReturn("Foo :id :version :blob");
  Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(statement);

  // Create our consumer
  final DatabaseDataSetConsumer consumer = new DatabaseDataSetConsumer(connectionResources, new SqlScriptExecutorProvider(dataSource, Providers.of(dialect)));
  consumer.open();

  // Create a mock schema and records
  final Table table = table("DatabaseTest")
    .columns(
      idColumn(),
      versionColumn(),
      column("blob", DataType.BLOB)
    );
  final List<Record> records = new ArrayList<>();
  records.add(record().setInteger(idColumn().getName(), 1).setInteger(versionColumn().getName(), 2).setString("blob", "QUJD"));

  // consume the records
  consumer.table(table, records);

  // Verify dialect is requested to write the values to the statement

  Mockito.verify(dialect).prepareStatementParameters(any(NamedParameterPreparedStatement.class), parametersCaptor.capture(), valuesCaptor.capture());

  assertThat(FluentIterable.from(parametersCaptor.getValue()).transform(SqlParameter::getImpliedName), contains(
    idColumn().getName(),
    versionColumn().getName(),
    "blob")
  );
  assertThat(valuesCaptor.getValue().getInteger(idColumn().getName()), equalTo(1));
  assertThat(valuesCaptor.getValue().getInteger(versionColumn().getName()), equalTo(2));
  assertThat(valuesCaptor.getValue().getString("blob"), equalTo("QUJD"));
}
 

@Before
public void setUp() {
  when(db.acquire()).thenReturn(tx);
  storageManager = new OrientKeyStoreStorageManager(Providers.of(db), entityAdapter, eventManager);
}