public record TestServices()

in service/common/src/testFixtures/java/org/apache/polaris/service/TestServices.java [69:264]
169 lines of code
1 McCabe index (conditional complexity)

public record TestServices(
    PolarisCatalogsApi catalogsApi,
    IcebergRestCatalogApi restApi,
    IcebergRestConfigurationApi restConfigurationApi,
    PolarisConfigurationStore configurationStore,
    PolarisDiagnostics polarisDiagnostics,
    RealmEntityManagerFactory entityManagerFactory,
    MetaStoreManagerFactory metaStoreManagerFactory,
    RealmContext realmContext,
    SecurityContext securityContext,
    FileIOFactory fileIOFactory,
    TaskExecutor taskExecutor,
    PolarisEventListener polarisEventListener) {

  private static final RealmContext TEST_REALM = () -> "test-realm";
  private static final String GCP_ACCESS_TOKEN = "abc";

  @FunctionalInterface
  public interface FileIOFactorySupplier
      extends TriFunction<
          RealmEntityManagerFactory,
          MetaStoreManagerFactory,
          PolarisConfigurationStore,
          FileIOFactory> {}

  public static Builder builder() {
    return new Builder();
  }

  public static class Builder {
    private RealmContext realmContext = TEST_REALM;
    private Map<String, Object> config = Map.of();
    private StsClient stsClient = Mockito.mock(StsClient.class);
    private FileIOFactorySupplier fileIOFactorySupplier = MeasuredFileIOFactory::new;

    private Builder() {}

    public Builder realmContext(RealmContext realmContext) {
      this.realmContext = realmContext;
      return this;
    }

    public Builder config(Map<String, Object> config) {
      this.config = config;
      return this;
    }

    public Builder fileIOFactorySupplier(FileIOFactorySupplier fileIOFactorySupplier) {
      this.fileIOFactorySupplier = fileIOFactorySupplier;
      return this;
    }

    public Builder stsClient(StsClient stsClient) {
      this.stsClient = stsClient;
      return this;
    }

    public TestServices build() {
      DefaultConfigurationStore configurationStore = new DefaultConfigurationStore(config);
      PolarisDiagnostics polarisDiagnostics = Mockito.mock(PolarisDiagnostics.class);
      PolarisAuthorizer authorizer = Mockito.mock(PolarisAuthorizer.class);

      // Application level
      PolarisStorageIntegrationProviderImpl storageIntegrationProvider =
          new PolarisStorageIntegrationProviderImpl(
              () -> stsClient,
              () -> GoogleCredentials.create(new AccessToken(GCP_ACCESS_TOKEN, new Date())));
      InMemoryPolarisMetaStoreManagerFactory metaStoreManagerFactory =
          new InMemoryPolarisMetaStoreManagerFactory(
              storageIntegrationProvider, polarisDiagnostics);
      RealmEntityManagerFactory realmEntityManagerFactory =
          new RealmEntityManagerFactory(metaStoreManagerFactory) {};
      UserSecretsManagerFactory userSecretsManagerFactory =
          new UnsafeInMemorySecretsManagerFactory();

      BasePersistence metaStoreSession =
          metaStoreManagerFactory.getOrCreateSessionSupplier(realmContext).get();
      CallContext callContext =
          new CallContext() {
            @Override
            public RealmContext getRealmContext() {
              return realmContext;
            }

            @Override
            public PolarisCallContext getPolarisCallContext() {
              return new PolarisCallContext(
                  metaStoreSession,
                  polarisDiagnostics,
                  configurationStore,
                  Mockito.mock(Clock.class));
            }

            @Override
            public Map<String, Object> contextVariables() {
              return new HashMap<>();
            }
          };
      CallContext.setCurrentContext(callContext);
      PolarisEntityManager entityManager =
          realmEntityManagerFactory.getOrCreateEntityManager(realmContext);
      PolarisMetaStoreManager metaStoreManager =
          metaStoreManagerFactory.getOrCreateMetaStoreManager(realmContext);
      UserSecretsManager userSecretsManager =
          userSecretsManagerFactory.getOrCreateUserSecretsManager(realmContext);

      FileIOFactory fileIOFactory =
          fileIOFactorySupplier.apply(
              realmEntityManagerFactory, metaStoreManagerFactory, configurationStore);

      TaskExecutor taskExecutor = Mockito.mock(TaskExecutor.class);

      PolarisEventListener polarisEventListener = new TestPolarisEventListener();
      CallContextCatalogFactory callContextFactory =
          new PolarisCallContextCatalogFactory(
              realmEntityManagerFactory,
              metaStoreManagerFactory,
              userSecretsManagerFactory,
              taskExecutor,
              fileIOFactory,
              polarisEventListener);

      IcebergCatalogAdapter service =
          new IcebergCatalogAdapter(
              realmContext,
              callContext,
              callContextFactory,
              entityManager,
              metaStoreManager,
              userSecretsManager,
              authorizer,
              new DefaultCatalogPrefixParser());

      IcebergRestCatalogApi restApi = new IcebergRestCatalogApi(service);
      IcebergRestConfigurationApi restConfigurationApi = new IcebergRestConfigurationApi(service);

      CreatePrincipalResult createdPrincipal =
          metaStoreManager.createPrincipal(
              callContext.getPolarisCallContext(),
              new PrincipalEntity.Builder()
                  .setName("test-principal")
                  .setCreateTimestamp(Instant.now().toEpochMilli())
                  .setCredentialRotationRequiredState()
                  .build());
      AuthenticatedPolarisPrincipal principal =
          new AuthenticatedPolarisPrincipal(
              PolarisEntity.of(createdPrincipal.getPrincipal()), Set.of());

      SecurityContext securityContext =
          new SecurityContext() {
            @Override
            public Principal getUserPrincipal() {
              return principal;
            }

            @Override
            public boolean isUserInRole(String s) {
              return false;
            }

            @Override
            public boolean isSecure() {
              return true;
            }

            @Override
            public String getAuthenticationScheme() {
              return "";
            }
          };

      PolarisCatalogsApi catalogsApi =
          new PolarisCatalogsApi(
              new PolarisServiceImpl(
                  realmEntityManagerFactory,
                  metaStoreManagerFactory,
                  userSecretsManagerFactory,
                  authorizer,
                  callContext));

      return new TestServices(
          catalogsApi,
          restApi,
          restConfigurationApi,
          configurationStore,
          polarisDiagnostics,
          realmEntityManagerFactory,
          metaStoreManagerFactory,
          realmContext,
          securityContext,
          fileIOFactory,
          taskExecutor,
          polarisEventListener);
    }
  }
}