com.apollographql.apollo.ApolloClient Java Examples

@Override
public ApolloClient create() {
  var builder = builder()
      .okHttpClient(new OkHttpClient.Builder().build());
  configurer.accept(builder);
  return builder
      .serverUrl(streamRegistryUrl)
      .addCustomTypeAdapter(OBJECTNODE, new ObjectNodeTypeAdapter())
      .build();
}
 

@Test public void defaultCacheControl() {
  ApolloClient apolloClient = ApolloClient.builder()
      .serverUrl("http://google.com")
      .okHttpClient(okHttpClient)
      .build();

  RealApolloCall realApolloCall = (RealApolloCall) apolloClient.query(emptyQuery);
  assertThat(realApolloCall.httpCachePolicy.fetchStrategy).isEqualTo(HttpCachePolicy.FetchStrategy.NETWORK_ONLY);
  assertThat(realApolloCall.responseFetcher).isEqualTo(CACHE_FIRST);
}
 

@Test public void setDefaultCachePolicy() {
  ApolloClient apolloClient = ApolloClient.builder()
      .serverUrl("http://google.com")
      .okHttpClient(okHttpClient)
      .defaultHttpCachePolicy(HttpCachePolicy.CACHE_ONLY)
      .defaultResponseFetcher(NETWORK_ONLY)
      .build();

  RealApolloCall realApolloCall = (RealApolloCall) apolloClient.query(emptyQuery);
  assertThat(realApolloCall.httpCachePolicy.fetchStrategy).isEqualTo(HttpCachePolicy.FetchStrategy.CACHE_ONLY);
  assertThat(realApolloCall.responseFetcher).isEqualTo(NETWORK_ONLY);
}
 

@Before
public void setUp() throws Exception {
  activeCallCounts = new ArrayList<>();
  Interceptor interceptor = new Interceptor() {
    @Override public okhttp3.Response intercept(Chain chain) throws IOException {
      activeCallCounts.add(apolloClient.activeCallsCount());
      return chain.proceed(chain.request());
    }
  };

  OkHttpClient okHttpClient = new OkHttpClient.Builder()
      .addInterceptor(interceptor)
      .build();

  apolloClient = ApolloClient.builder()
      .serverUrl(SERVER_URL)
      .okHttpClient(okHttpClient)
      .build();
}
 

@Before public void setUp() throws IOException {
  server = new MockWebServer();
  server.start();
  OkHttpClient okHttpClient = new OkHttpClient.Builder()
      .dispatcher(new Dispatcher(Utils.INSTANCE.immediateExecutorService()))
      .build();

  apolloClient = ApolloClient.builder()
      .serverUrl(server.url("/"))
      .dispatcher(Utils.INSTANCE.immediateExecutor())
      .okHttpClient(okHttpClient)
      .normalizedCache(new LruNormalizedCacheFactory(EvictionPolicy.NO_EVICTION), new IdFieldCacheKeyResolver())
      .build();
}
 

@Before public void setUp() {
  server = new MockWebServer();
  OkHttpClient okHttpClient = new OkHttpClient.Builder()
      .writeTimeout(2, TimeUnit.SECONDS)
      .readTimeout(2, TimeUnit.SECONDS)
      .dispatcher(new Dispatcher(Utils.INSTANCE.immediateExecutorService()))
      .build();

  apolloClient = ApolloClient.builder()
      .serverUrl(server.url("/"))
      .okHttpClient(okHttpClient)
      .normalizedCache(new LruNormalizedCacheFactory(EvictionPolicy.NO_EVICTION), new IdFieldCacheKeyResolver())
      .dispatcher(Utils.INSTANCE.immediateExecutor())
      .build();
}
 

@Test
public void checkIdlingResourceTransition_whenCallIsQueued() throws ApolloException {
  server.enqueue(mockResponse());

  apolloClient = ApolloClient.builder()
      .okHttpClient(okHttpClient)
      .dispatcher(new Executor() {
        @Override public void execute(@NotNull Runnable command) {
          command.run();
        }
      })
      .serverUrl(server.url("/"))
      .build();

  final AtomicInteger counter = new AtomicInteger(1);
  idlingResource = ApolloIdlingResource.create(IDLING_RESOURCE_NAME, apolloClient);

  idlingResource.registerIdleTransitionCallback(new IdlingResource.ResourceCallback() {
    @Override public void onTransitionToIdle() {
      counter.decrementAndGet();
    }
  });

  assertThat(counter.get()).isEqualTo(1);
  Rx2Apollo.from(apolloClient.query(EMPTY_QUERY)).test().awaitTerminalEvent();
  assertThat(counter.get()).isEqualTo(0);
}
 

@Test
public void checkIsIdleNow_whenCallIsWatched() throws InterruptedException {
  server.enqueue(mockResponse());

  final CountDownLatch latch = new CountDownLatch(1);

  ExecutorService executorService = Executors.newFixedThreadPool(1);

  apolloClient = ApolloClient.builder()
      .okHttpClient(okHttpClient)
      .dispatcher(executorService)
      .serverUrl(server.url("/"))
      .build();

  idlingResource = ApolloIdlingResource.create(IDLING_RESOURCE_NAME, apolloClient);
  assertThat(idlingResource.isIdleNow()).isTrue();

  apolloClient.query(EMPTY_QUERY).watcher().enqueueAndWatch(new ApolloCall.Callback<Object>() {
    @Override public void onResponse(@NotNull Response<Object> response) {
      latch.countDown();
    }

    @Override public void onFailure(@NotNull ApolloException e) {
      throw new AssertionError("This callback can't be called.");
    }
  });

  assertThat(idlingResource.isIdleNow()).isFalse();

  latch.await(TIME_OUT_SECONDS, TimeUnit.SECONDS);

  executorService.shutdown();
  executorService.awaitTermination(TIME_OUT_SECONDS, TimeUnit.SECONDS);
  Thread.sleep(100);
  assertThat(idlingResource.isIdleNow()).isTrue();
}
 

@Test
public void checkIsIdleNow_whenCallIsQueued() throws InterruptedException {
  server.enqueue(mockResponse());

  final CountDownLatch latch = new CountDownLatch(1);

  ExecutorService executorService = Executors.newFixedThreadPool(1);

  apolloClient = ApolloClient.builder()
      .okHttpClient(okHttpClient)
      .dispatcher(executorService)
      .serverUrl(server.url("/"))
      .build();

  idlingResource = ApolloIdlingResource.create(IDLING_RESOURCE_NAME, apolloClient);
  assertThat(idlingResource.isIdleNow()).isTrue();

  apolloClient.query(EMPTY_QUERY).enqueue(new ApolloCall.Callback<Object>() {
    @Override public void onResponse(@NotNull Response<Object> response) {
      latch.countDown();
    }

    @Override public void onFailure(@NotNull ApolloException e) {
      throw new AssertionError("This callback can't be called.");
    }
  });
  assertThat(idlingResource.isIdleNow()).isFalse();

  latch.await(TIME_OUT_SECONDS, TimeUnit.SECONDS);

  executorService.shutdown();
  executorService.awaitTermination(TIME_OUT_SECONDS, TimeUnit.SECONDS);
  Thread.sleep(100);
  assertThat(idlingResource.isIdleNow()).isTrue();
}
 

public static ApolloClient getApolloClient(String authToken) {

        if (okHttpClient == null) {
            okHttpClient = getOkHttpClient(authToken);
        }

        return ApolloClient.builder()
                .serverUrl(YELP_API)
                .okHttpClient(okHttpClient)
                .build();
    }
 

@Test
public void checkValidIdlingResourceNameIsRegistered() {
  apolloClient = ApolloClient.builder()
      .okHttpClient(okHttpClient)
      .serverUrl(server.url("/"))
      .build();

  idlingResource = ApolloIdlingResource.create(IDLING_RESOURCE_NAME, apolloClient);

  assertThat(idlingResource.getName()).isEqualTo(IDLING_RESOURCE_NAME);
}
 

@SuppressWarnings("ConstantConditions") @Test
public void onNullNamePassed_NullPointerExceptionIsThrown() {
  apolloClient = ApolloClient.builder()
      .okHttpClient(okHttpClient)
      .serverUrl(server.url("/"))
      .build();

  try {
    idlingResource = ApolloIdlingResource.create(null, apolloClient);
    fail();
  } catch (Exception e) {
    assertThat(e).isInstanceOf(NullPointerException.class);
    assertThat(e.getMessage()).isEqualTo("name == null");
  }
}
 

@Inject
OverviewViewModel(UserManager userManager,
                         UserRestService service,
                         OrganizationService organizationService,
                         ApolloClient apolloClient) {
    super(userManager);
    this.userRestService = service;
    this.organizationService = organizationService;
    this.apolloClient = apolloClient;
}
 

private ApolloIdlingResource(String name, ApolloClient apolloClient) {
  this.apolloClient = apolloClient;
  this.name = name;
  apolloClient.idleCallback(new IdleResourceCallback() {
    @Override public void onIdle() {
      ResourceCallback callback = ApolloIdlingResource.this.callback;
      if (callback != null) {
        callback.onTransitionToIdle();
      }
    }
  });
}
 

public ApolloClient apolloClient() {
  return apolloClient;
}
 

@Bean
ApolloClient apolloClient(
    @Value("${streamRegistryUrl}") String streamRegistryUrl
) {
  return new DefaultApolloClientFactory(streamRegistryUrl).create();
}
 

@Provides
@Singleton
static ApolloClient provideApolloClient() {
    return mock(ApolloClient.class);
}
 

public static ApolloClient getApollo(OkHttpClient okHttpClient) {
    return ApolloClient.builder()
            .serverUrl(BuildConfig.REST_URL + "graphql")
            .okHttpClient(okHttpClient)
            .build();
}
 

@Provides
@Singleton
static ApolloClient provideApolloClient(OkHttpClient okHttpClient) {
    return ApolloProvider.getApollo(okHttpClient);
}
 

public CommandFollowUser(ApolloClient apolloClient, Long targetUserId, Boolean goLiveNotification) {
    super(apolloClient);
    this.targetUserId = targetUserId;
    this.goLiveNotification = goLiveNotification;
}
 

public CommandUnfollowUser(ApolloClient apolloClient, Long targetUserId) {
    super(apolloClient);
    this.targetUserId = targetUserId;
}
 

public ApolloClient apolloClient() {
    return apolloClient;
}
 

public StreamRegistryClient(ApolloClient apolloClient) {
  this(new ApolloExecutor(apolloClient));
}
 

public GraphQLEventSender(ApolloClient client) {
  this(new ApolloExecutor(client), new GraphQLConverter());
}
 

ApolloClient.Builder builder() {
  return ApolloClient.builder();
}
 

@Bean
EventSender eventSender(ApolloClient apolloClient) {
  return new GraphQLEventSender(apolloClient);
}
 

/**
 * Creates a new {@link IdlingResource} from {@link ApolloClient} with a given name. Register this instance using
 * {@link androidx.test.espresso.IdlingRegistry} in your test suite's setup method.
 *
 * <pre>{@code
 * IdlingResource idlingResource = ApolloIdlingResource.create("Apollo", apolloClient);
 * IdlingRegistry.getInstance().register(idlingResource);
 * }</pre>
 *
 * @param name <strong>unique</strong> name of this IdlingResource instance.
 * @param apolloClient the apolloClient for which IdlingResource needs to be created.
 * @return a new ApolloIdlingResource.
 * @throws NullPointerException if name == null or apolloClient == null
 */
public static ApolloIdlingResource create(@NotNull String name, @NotNull ApolloClient apolloClient) {
  checkNotNull(name, "name == null");
  checkNotNull(apolloClient, "apolloClient == null");
  return new ApolloIdlingResource(name, apolloClient);
}
 

/**
 * Constructor
 *
 * @param apolloClient Apollo Client
 */
public BaseCommand(ApolloClient apolloClient) {
    super(HystrixCommandGroupKey.Factory.asKey("GraphQL"));
    this.apolloClient = apolloClient;
}
 

ApolloClient create();