From cfca7f4b1a4fb0e97d2c918f7284c15a790e8bc8 Mon Sep 17 00:00:00 2001 From: Lawrence Qiu Date: Fri, 17 Jul 2026 22:10:54 +0000 Subject: [PATCH 1/2] test(bigtable): fix remaining JSpecify CI issues on Java 8 Disable annotations in Mockito mocks for GAX classes across 17 test files in `google-cloud-bigtable` to avoid ArrayStoreException on Java 8. These tests were missed in the previous round of fixes. TAG=agy CONV=de3ef09d-a26c-4190-b578-4c993f807bdc --- .../v2/BigtableTableAdminClientTests.java | 2 +- .../v2/BigtableTableAdminSettingsTest.java | 3 +- .../v2/stub/AwaitConsistencyCallableTest.java | 8 +- .../stub/AwaitConsistencyCallableV2Test.java | 8 +- .../v2/BigtableDataClientFactoryTest.java | 33 +++++--- .../data/v2/BigtableDataClientTests.java | 75 ++++++++++++++----- .../v2/internal/csm/MetricsIsolationTest.java | 2 +- .../BigtableCloudMonitoringExporterTest.java | 16 ++-- .../csm/opencensus/MetricsTracerTest.java | 9 ++- .../csm/tracers/CompositeTracerTest.java | 23 +++--- .../BigtableUnaryOperationCallableTest.java | 9 ++- .../EnhancedBigtableStubSettingsTest.java | 9 ++- .../v2/stub/RateLimitingCallableTest.java | 5 +- .../data/v2/stub/SkipTrailersTest.java | 5 +- .../MutateRowsAttemptCallableTest.java | 2 +- ...teRowsErrorConverterUnaryCallableTest.java | 5 +- .../ReframingResponseObserverTest.java | 3 +- 17 files changed, 146 insertions(+), 71 deletions(-) diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/BigtableTableAdminClientTests.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/BigtableTableAdminClientTests.java index 67b30c1f8213..cecf509db1a7 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/BigtableTableAdminClientTests.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/BigtableTableAdminClientTests.java @@ -1749,7 +1749,7 @@ public void testAwaitOptimizeRestoredTable() throws Exception { // 4. Mock the Stub's behavior (resuming the Optimize Op) OperationFuture mockOptimizeOp = - Mockito.mock(OperationFuture.class); + Mockito.mock(OperationFuture.class, Mockito.withSettings().withoutAnnotations()); Mockito.when(mockOptimizeRestoredTableCallable.resumeFutureCall(optimizeToken)) .thenReturn(mockOptimizeOp); diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/BigtableTableAdminSettingsTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/BigtableTableAdminSettingsTest.java index 0aac3b8c99d3..a7497f759a1a 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/BigtableTableAdminSettingsTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/BigtableTableAdminSettingsTest.java @@ -65,7 +65,8 @@ public void testMissingInstanceName() { @Test public void testCredentials() throws IOException { - CredentialsProvider credentialsProvider = Mockito.mock(CredentialsProvider.class); + CredentialsProvider credentialsProvider = + Mockito.mock(CredentialsProvider.class, Mockito.withSettings().withoutAnnotations()); BigtableTableAdminSettings settings = BigtableTableAdminSettings.newBuilder() diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/stub/AwaitConsistencyCallableTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/stub/AwaitConsistencyCallableTest.java index 52e8956a0dec..292eee3569e8 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/stub/AwaitConsistencyCallableTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/stub/AwaitConsistencyCallableTest.java @@ -43,7 +43,6 @@ import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import org.mockito.ArgumentMatchers; -import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -63,11 +62,9 @@ public class AwaitConsistencyCallableTest { private static final TableAdminRequestContext REQUEST_CONTEXT = TableAdminRequestContext.create(PROJECT_ID, INSTANCE_ID); - @Mock private UnaryCallable mockGenerateConsistencyTokenCallable; - @Mock private UnaryCallable mockCheckConsistencyCallable; @@ -77,6 +74,11 @@ public class AwaitConsistencyCallableTest { @Before public void setUp() { + mockGenerateConsistencyTokenCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); + mockCheckConsistencyCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); + ClientContext clientContext = ClientContext.newBuilder().setDefaultCallContext(CALL_CONTEXT).build(); diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/stub/AwaitConsistencyCallableV2Test.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/stub/AwaitConsistencyCallableV2Test.java index 4fe205810d82..396e71caa7af 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/stub/AwaitConsistencyCallableV2Test.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/stub/AwaitConsistencyCallableV2Test.java @@ -42,7 +42,6 @@ import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import org.mockito.ArgumentMatchers; -import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -59,11 +58,9 @@ public class AwaitConsistencyCallableV2Test { private static final TableName TABLE_NAME = TableName.of(PROJECT_ID, INSTANCE_ID, TABLE_ID); private static final ApiCallContext CALL_CONTEXT = FakeCallContext.createDefault(); - @Mock private UnaryCallable mockGenerateConsistencyTokenCallable; - @Mock private UnaryCallable mockCheckConsistencyCallable; @@ -71,6 +68,11 @@ public class AwaitConsistencyCallableV2Test { @Before public void setUp() { + mockGenerateConsistencyTokenCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); + mockCheckConsistencyCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); + RetrySettings retrySettings = RetrySettings.newBuilder() .setTotalTimeout(Duration.ofMillis(100)) diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientFactoryTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientFactoryTest.java index 30a4853a618d..f3cef473c424 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientFactoryTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientFactoryTest.java @@ -134,27 +134,42 @@ public void transportTerminated(Attributes transportAttrs) { transportChannelProvider = Mockito.mock( TransportChannelProvider.class, - new BuilderAnswer<>( - TransportChannelProvider.class, - builder.stubSettings().getTransportChannelProvider())); + Mockito.withSettings() + .withoutAnnotations() + .defaultAnswer( + new BuilderAnswer<>( + TransportChannelProvider.class, + builder.stubSettings().getTransportChannelProvider()))); credentialsProvider = Mockito.mock( CredentialsProvider.class, - new BuilderAnswer<>( - CredentialsProvider.class, builder.stubSettings().getCredentialsProvider())); + Mockito.withSettings() + .withoutAnnotations() + .defaultAnswer( + new BuilderAnswer<>( + CredentialsProvider.class, + builder.stubSettings().getCredentialsProvider()))); executorProvider = Mockito.mock( ExecutorProvider.class, - new BuilderAnswer<>( - ExecutorProvider.class, builder.stubSettings().getBackgroundExecutorProvider())); + Mockito.withSettings() + .withoutAnnotations() + .defaultAnswer( + new BuilderAnswer<>( + ExecutorProvider.class, + builder.stubSettings().getBackgroundExecutorProvider()))); watchdogProvider = Mockito.mock( WatchdogProvider.class, - new BuilderAnswer<>( - WatchdogProvider.class, builder.stubSettings().getStreamWatchdogProvider())); + Mockito.withSettings() + .withoutAnnotations() + .defaultAnswer( + new BuilderAnswer<>( + WatchdogProvider.class, + builder.stubSettings().getStreamWatchdogProvider()))); ApiClock apiClock = builder.stubSettings().getClock(); diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientTests.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientTests.java index c8a999a625ab..af1e95900754 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientTests.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientTests.java @@ -59,7 +59,6 @@ import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import org.mockito.ArgumentMatchers; -import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -76,36 +75,68 @@ public class BigtableDataClientTests { @Rule public MockitoRule mockitoRule = MockitoJUnit.rule().strictness(Strictness.WARN); - @Mock private EnhancedBigtableStub mockStub; + private EnhancedBigtableStub mockStub; - @Mock private ServerStreamingCallable mockReadRowsCallable; + private ServerStreamingCallable mockReadRowsCallable; - @Mock private UnaryCallable mockReadRowCallable; - @Mock private UnaryCallable> mockSampleRowKeysCallable; + private UnaryCallable mockReadRowCallable; + private UnaryCallable> mockSampleRowKeysCallable; - @Mock private UnaryCallable> mockSampleRowKeysCallableWithRequest; - @Mock private UnaryCallable mockMutateRowCallable; - @Mock private UnaryCallable mockCheckAndMutateRowCallable; - @Mock private UnaryCallable mockReadModifyWriteRowCallable; - @Mock private UnaryCallable mockBulkMutateRowsCallable; - @Mock private Batcher mockBulkMutationBatcher; - @Mock private Batcher mockBulkReadRowsBatcher; - @Mock private UnaryCallable mockPrepareQueryCallable; + private UnaryCallable mockMutateRowCallable; + private UnaryCallable mockCheckAndMutateRowCallable; + private UnaryCallable mockReadModifyWriteRowCallable; + private UnaryCallable mockBulkMutateRowsCallable; + private Batcher mockBulkMutationBatcher; + private Batcher mockBulkReadRowsBatcher; + private UnaryCallable mockPrepareQueryCallable; - @Mock private ServerStreamingCallable mockGenerateInitialChangeStreamPartitionsCallable; - - @Mock private ServerStreamingCallable mockReadChangeStreamCallable; private BigtableDataClient bigtableDataClient; @Before + @SuppressWarnings("unchecked") public void setUp() { + mockStub = + Mockito.mock(EnhancedBigtableStub.class, Mockito.withSettings().withoutAnnotations()); + mockReadRowsCallable = + Mockito.mock( + ServerStreamingCallable.class, + Mockito.withSettings().withoutAnnotations().defaultAnswer(Answers.RETURNS_DEEP_STUBS)); + mockReadRowCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); + mockSampleRowKeysCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); + mockSampleRowKeysCallableWithRequest = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); + mockMutateRowCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); + mockCheckAndMutateRowCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); + mockReadModifyWriteRowCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); + mockBulkMutateRowsCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); + mockBulkMutationBatcher = + Mockito.mock(Batcher.class, Mockito.withSettings().withoutAnnotations()); + mockBulkReadRowsBatcher = + Mockito.mock(Batcher.class, Mockito.withSettings().withoutAnnotations()); + mockPrepareQueryCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); + mockGenerateInitialChangeStreamPartitionsCallable = + Mockito.mock( + ServerStreamingCallable.class, + Mockito.withSettings().withoutAnnotations().defaultAnswer(Answers.RETURNS_DEEP_STUBS)); + mockReadChangeStreamCallable = + Mockito.mock( + ServerStreamingCallable.class, + Mockito.withSettings().withoutAnnotations().defaultAnswer(Answers.RETURNS_DEEP_STUBS)); + bigtableDataClient = new BigtableDataClient(mockStub); } @@ -597,7 +628,8 @@ public void proxyReadRowsAsyncTest() { Query query = Query.create(TableId.of("fake-table")); @SuppressWarnings("unchecked") - ResponseObserver mockObserver = Mockito.mock(ResponseObserver.class); + ResponseObserver mockObserver = + Mockito.mock(ResponseObserver.class, Mockito.withSettings().withoutAnnotations()); bigtableDataClient.readRowsAsync(query, mockObserver); Mockito.verify(mockReadRowsCallable).call(query, mockObserver); @@ -609,7 +641,8 @@ public void proxyReadRowsOnAuthorizedViewAsyncTest() { Query query = Query.create(AuthorizedViewId.of("fake-table", "fake-authorized-view")); @SuppressWarnings("unchecked") - ResponseObserver mockObserver = Mockito.mock(ResponseObserver.class); + ResponseObserver mockObserver = + Mockito.mock(ResponseObserver.class, Mockito.withSettings().withoutAnnotations()); bigtableDataClient.readRowsAsync(query, mockObserver); Mockito.verify(mockReadRowsCallable).call(query, mockObserver); @@ -631,7 +664,8 @@ public void proxyGenerateInitialChangeStreamPartitionsAsyncTest() { .thenReturn(mockGenerateInitialChangeStreamPartitionsCallable); @SuppressWarnings("unchecked") - ResponseObserver mockObserver = Mockito.mock(ResponseObserver.class); + ResponseObserver mockObserver = + Mockito.mock(ResponseObserver.class, Mockito.withSettings().withoutAnnotations()); bigtableDataClient.generateInitialChangeStreamPartitionsAsync("fake-table", mockObserver); Mockito.verify(mockGenerateInitialChangeStreamPartitionsCallable) @@ -653,7 +687,8 @@ public void proxyReadChangeStreamAsyncTest() { Mockito.when(mockStub.readChangeStreamCallable()).thenReturn(mockReadChangeStreamCallable); @SuppressWarnings("unchecked") - ResponseObserver mockObserver = Mockito.mock(ResponseObserver.class); + ResponseObserver mockObserver = + Mockito.mock(ResponseObserver.class, Mockito.withSettings().withoutAnnotations()); ReadChangeStreamQuery query = ReadChangeStreamQuery.create("fake-table"); bigtableDataClient.readChangeStreamAsync(query, mockObserver); diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/MetricsIsolationTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/MetricsIsolationTest.java index bc4b3a8eb263..666ec66352fa 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/MetricsIsolationTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/MetricsIsolationTest.java @@ -107,7 +107,7 @@ void setUp() { new MetricsImpl( registry, clientInfo, - Mockito.mock(ApiTracerFactory.class), + Mockito.mock(ApiTracerFactory.class, Mockito.withSettings().withoutAnnotations()), internalOtel, userOtel, Mockito.mock(Tagger.class), diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/exporter/BigtableCloudMonitoringExporterTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/exporter/BigtableCloudMonitoringExporterTest.java index 10c66920c83d..a37382489d11 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/exporter/BigtableCloudMonitoringExporterTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/exporter/BigtableCloudMonitoringExporterTest.java @@ -17,7 +17,6 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.mock; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -144,7 +143,8 @@ public void testExportingSumData() { ArgumentCaptor argumentCaptor = ArgumentCaptor.forClass(CreateTimeSeriesRequest.class); - UnaryCallable mockCallable = mock(UnaryCallable.class); + UnaryCallable mockCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); when(mockMetricServiceStub.createServiceTimeSeriesCallable()).thenReturn(mockCallable); ApiFuture future = ApiFutures.immediateFuture(Empty.getDefaultInstance()); when(mockCallable.futureCall(argumentCaptor.capture())).thenReturn(future); @@ -201,7 +201,8 @@ public void testExportingHistogramData() { ArgumentCaptor argumentCaptor = ArgumentCaptor.forClass(CreateTimeSeriesRequest.class); - UnaryCallable mockCallable = mock(UnaryCallable.class); + UnaryCallable mockCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); when(mockMetricServiceStub.createServiceTimeSeriesCallable()).thenReturn(mockCallable); ApiFuture future = ApiFutures.immediateFuture(Empty.getDefaultInstance()); when(mockCallable.futureCall(argumentCaptor.capture())).thenReturn(future); @@ -267,7 +268,8 @@ public void testExportingSumDataInBatches() { ArgumentCaptor argumentCaptor = ArgumentCaptor.forClass(CreateTimeSeriesRequest.class); - UnaryCallable mockCallable = mock(UnaryCallable.class); + UnaryCallable mockCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); when(mockMetricServiceStub.createServiceTimeSeriesCallable()).thenReturn(mockCallable); ApiFuture future = ApiFutures.immediateFuture(Empty.getDefaultInstance()); when(mockCallable.futureCall(argumentCaptor.capture())).thenReturn(future); @@ -352,7 +354,8 @@ public void testTimeSeriesForMetricWithGceOrGkeResource() { ArgumentCaptor argumentCaptor = ArgumentCaptor.forClass(CreateTimeSeriesRequest.class); - UnaryCallable mockCallable = mock(UnaryCallable.class); + UnaryCallable mockCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); when(mockMetricServiceStub.createServiceTimeSeriesCallable()).thenReturn(mockCallable); ApiFuture future = ApiFutures.immediateFuture(Empty.getDefaultInstance()); when(mockCallable.futureCall(argumentCaptor.capture())).thenReturn(future); @@ -430,7 +433,8 @@ public void testExportingToMultipleProjects() { ArgumentCaptor argumentCaptor = ArgumentCaptor.forClass(CreateTimeSeriesRequest.class); - UnaryCallable mockCallable = mock(UnaryCallable.class); + UnaryCallable mockCallable = + Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); when(mockMetricServiceStub.createServiceTimeSeriesCallable()).thenReturn(mockCallable); ApiFuture future = ApiFutures.immediateFuture(Empty.getDefaultInstance()); when(mockCallable.futureCall(any())).thenReturn(future); diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/opencensus/MetricsTracerTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/opencensus/MetricsTracerTest.java index e31e58d66423..b418e8a78569 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/opencensus/MetricsTracerTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/opencensus/MetricsTracerTest.java @@ -73,7 +73,6 @@ import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import org.mockito.Answers; -import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -104,7 +103,6 @@ public class MetricsTracerTest { private Server server; - @Mock(answer = Answers.CALLS_REAL_METHODS) private BigtableGrpc.BigtableImplBase mockService; private final StatsComponent localStats = new SimpleStatsComponent(); @@ -113,6 +111,10 @@ public class MetricsTracerTest { @Before public void setUp() throws Exception { + mockService = + Mockito.mock( + BigtableGrpc.BigtableImplBase.class, + Mockito.withSettings().withoutAnnotations().defaultAnswer(Answers.CALLS_REAL_METHODS)); server = FakeServiceBuilder.create(mockService).start(); com.google.cloud.bigtable.data.v2.stub.metrics.RpcViews.registerBigtableClientViews( @@ -414,7 +416,8 @@ public void testBatchReadRowsThrottledTime() throws Exception { @Test public void testBatchMutateRowsThrottledTime() throws Exception { - FlowController flowController = Mockito.mock(FlowController.class); + FlowController flowController = + Mockito.mock(FlowController.class, Mockito.withSettings().withoutAnnotations()); MutateRowsBatchingDescriptor batchingDescriptor = new MutateRowsBatchingDescriptor(); // Mock throttling diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/tracers/CompositeTracerTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/tracers/CompositeTracerTest.java index c77f3e1e50f4..478b2e4b75a8 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/tracers/CompositeTracerTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/tracers/CompositeTracerTest.java @@ -17,7 +17,6 @@ import static com.google.api.gax.util.TimeConversionUtils.toThreetenDuration; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Mockito.mock; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -37,7 +36,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; -import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -45,30 +44,34 @@ public class CompositeTracerTest { @Rule public final MockitoRule mockitoRule = MockitoJUnit.rule(); - @Mock private ApiTracer child1; - @Mock private ApiTracer child2; - @Mock private BigtableTracer child3; - @Mock private BigtableTracer child4; + private ApiTracer child1; + private ApiTracer child2; + private BigtableTracer child3; + private BigtableTracer child4; private CompositeTracer compositeTracer; @Before public void setup() { + child1 = Mockito.mock(ApiTracer.class, Mockito.withSettings().withoutAnnotations()); + child2 = Mockito.mock(ApiTracer.class, Mockito.withSettings().withoutAnnotations()); + child3 = Mockito.mock(BigtableTracer.class, Mockito.withSettings().withoutAnnotations()); + child4 = Mockito.mock(BigtableTracer.class, Mockito.withSettings().withoutAnnotations()); compositeTracer = new CompositeTracer(ImmutableList.of(child1, child2, child3, child4)); } @Test public void testInScope() { - Scope scope1 = mock(Scope.class); + Scope scope1 = Mockito.mock(Scope.class, Mockito.withSettings().withoutAnnotations()); when(child1.inScope()).thenReturn(scope1); - Scope scope2 = mock(Scope.class); + Scope scope2 = Mockito.mock(Scope.class, Mockito.withSettings().withoutAnnotations()); when(child2.inScope()).thenReturn(scope2); - Scope scope3 = mock(Scope.class); + Scope scope3 = Mockito.mock(Scope.class, Mockito.withSettings().withoutAnnotations()); when(child3.inScope()).thenReturn(scope3); - Scope scope4 = mock(Scope.class); + Scope scope4 = Mockito.mock(Scope.class, Mockito.withSettings().withoutAnnotations()); when(child4.inScope()).thenReturn(scope4); Scope parentScope = compositeTracer.inScope(); diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/BigtableUnaryOperationCallableTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/BigtableUnaryOperationCallableTest.java index 2b07044c9a74..82f33ed68a78 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/BigtableUnaryOperationCallableTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/BigtableUnaryOperationCallableTest.java @@ -37,7 +37,6 @@ import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import org.mockito.ArgumentCaptor; -import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -46,11 +45,15 @@ public class BigtableUnaryOperationCallableTest { @Rule public final MockitoRule mockitoRule = MockitoJUnit.rule(); - @Mock private ApiTracerFactory tracerFactory; - @Mock private BigtableTracer tracer; + private ApiTracerFactory tracerFactory; + private BigtableTracer tracer; @Before public void setUp() throws Exception { + tracerFactory = + Mockito.mock(ApiTracerFactory.class, Mockito.withSettings().withoutAnnotations()); + tracer = Mockito.mock(BigtableTracer.class, Mockito.withSettings().withoutAnnotations()); + Mockito.when(tracerFactory.newTracer(Mockito.any(), Mockito.any(), Mockito.any())) .thenReturn(tracer); } diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/EnhancedBigtableStubSettingsTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/EnhancedBigtableStubSettingsTest.java index 971f2646263e..f86b78cfe86e 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/EnhancedBigtableStubSettingsTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/EnhancedBigtableStubSettingsTest.java @@ -78,8 +78,10 @@ public void settingsAreNotLostTest() { String appProfileId = "my-app-profile-id"; boolean isRefreshingChannel = false; String endpoint = "some.other.host:123"; - CredentialsProvider credentialsProvider = Mockito.mock(CredentialsProvider.class); - WatchdogProvider watchdogProvider = Mockito.mock(WatchdogProvider.class); + CredentialsProvider credentialsProvider = + Mockito.mock(CredentialsProvider.class, Mockito.withSettings().withoutAnnotations()); + WatchdogProvider watchdogProvider = + Mockito.mock(WatchdogProvider.class, Mockito.withSettings().withoutAnnotations()); Duration watchdogInterval = Duration.ofSeconds(12); String metricsEndpoint = "test-endpoint:443"; @@ -963,7 +965,8 @@ void checkToString(EnhancedBigtableStubSettings settings) { public void refreshingChannelSetFixedCredentialProvider() throws Exception { String dummyProjectId = "my-project"; String dummyInstanceId = "my-instance"; - CredentialsProvider credentialsProvider = Mockito.mock(CredentialsProvider.class); + CredentialsProvider credentialsProvider = + Mockito.mock(CredentialsProvider.class, Mockito.withSettings().withoutAnnotations()); FakeCredentials expectedCredentials = new FakeCredentials(); Mockito.when(credentialsProvider.getCredentials()) .thenReturn(expectedCredentials, new FakeCredentials(), new FakeCredentials()); diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/RateLimitingCallableTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/RateLimitingCallableTest.java index 652049b26678..b36e5c0b563e 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/RateLimitingCallableTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/RateLimitingCallableTest.java @@ -49,7 +49,7 @@ public class RateLimitingCallableTest { private final MutateRowsRequest request = MutateRowsRequest.newBuilder().getDefaultInstanceForType(); private final ResponseObserver responseObserver = - Mockito.mock(ResponseObserver.class); + Mockito.mock(ResponseObserver.class, Mockito.withSettings().withoutAnnotations()); private final ApiCallContext context = GrpcCallContext.createDefault(); private MockCallable innerCallable; RateLimitingServerStreamingCallable callableToTest; @@ -331,7 +331,8 @@ public void call( callableToTest = new RateLimitingServerStreamingCallable(innerCallable); - ResponseObserver mockObserver = Mockito.mock(ResponseObserver.class); + ResponseObserver mockObserver = + Mockito.mock(ResponseObserver.class, Mockito.withSettings().withoutAnnotations()); MutateRowsRequest req = MutateRowsRequest.newBuilder() diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/SkipTrailersTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/SkipTrailersTest.java index 40f7e5b17ad7..eed4454b6b64 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/SkipTrailersTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/SkipTrailersTest.java @@ -67,7 +67,6 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; -import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -83,13 +82,15 @@ public class SkipTrailersTest { private HackedBigtableService hackedService; private Server server; - @Mock private ApiTracerFactory tracerFactory; + private ApiTracerFactory tracerFactory; private FakeTracer tracer = new FakeTracer(); private BigtableDataClient client; @Before public void setUp() throws Exception { + tracerFactory = + Mockito.mock(ApiTracerFactory.class, Mockito.withSettings().withoutAnnotations()); hackedService = new HackedBigtableService(); server = FakeServiceBuilder.create(hackedService).start(); diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/mutaterows/MutateRowsAttemptCallableTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/mutaterows/MutateRowsAttemptCallableTest.java index 60ec5193e45a..d0c1f209d40f 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/mutaterows/MutateRowsAttemptCallableTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/mutaterows/MutateRowsAttemptCallableTest.java @@ -67,7 +67,7 @@ public class MutateRowsAttemptCallableTest { private ApiCallContext callContext; private MockRetryingFuture parentFuture; private final RetryAlgorithm mockRetryAlgorithm = - Mockito.mock(RetryAlgorithm.class); + Mockito.mock(RetryAlgorithm.class, Mockito.withSettings().withoutAnnotations()); @Before public void setUp() { diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/mutaterows/MutateRowsErrorConverterUnaryCallableTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/mutaterows/MutateRowsErrorConverterUnaryCallableTest.java index 7f2de3e72844..31a3634d2480 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/mutaterows/MutateRowsErrorConverterUnaryCallableTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/stub/mutaterows/MutateRowsErrorConverterUnaryCallableTest.java @@ -36,7 +36,6 @@ import org.junit.runners.JUnit4; import org.mockito.ArgumentCaptor; import org.mockito.Captor; -import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -45,14 +44,16 @@ public class MutateRowsErrorConverterUnaryCallableTest { private static final TableId TABLE_ID = TableId.of("fake-table"); - @Mock private UnaryCallable innerCallable; + private UnaryCallable innerCallable; @Captor private ArgumentCaptor innerMutation; private SettableApiFuture innerResult; @Rule public final MockitoRule mockitoRule = MockitoJUnit.rule(); @Before + @SuppressWarnings("unchecked") public void setUp() { + innerCallable = Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); innerResult = SettableApiFuture.create(); Mockito.when(innerCallable.futureCall(innerMutation.capture(), Mockito.any())) .thenReturn(innerResult); diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/gaxx/reframing/ReframingResponseObserverTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/gaxx/reframing/ReframingResponseObserverTest.java index 576dd919448b..acd5799aa604 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/gaxx/reframing/ReframingResponseObserverTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/gaxx/reframing/ReframingResponseObserverTest.java @@ -419,7 +419,8 @@ public String pop() { new ReframingResponseObserver<>(outerObserver, brokenReframer); // Configure the mock inner controller to fail cancellation. - StreamController mockInnerController = Mockito.mock(StreamController.class); + StreamController mockInnerController = + Mockito.mock(StreamController.class, Mockito.withSettings().withoutAnnotations()); RuntimeException fakeCancelError = new RuntimeException("fake cancel error"); Mockito.doThrow(fakeCancelError).when(mockInnerController).cancel(); From 4b773f9d18d3f19546c7af8699b4feaa331bae09 Mon Sep 17 00:00:00 2001 From: Lawrence Qiu Date: Mon, 20 Jul 2026 16:33:34 +0000 Subject: [PATCH 2/2] test(bigtable): remove unnecessary deep stubs from streaming callable mocks Remove `defaultAnswer(Answers.RETURNS_DEEP_STUBS)` from programmatic mocks of `ServerStreamingCallable` in `BigtableDataClientTests`. Mockito's deep stubs cause reflection crashes on Java 8 when dealing with JSpecify annotations. Since the tests do not rely on deep stubs for these callables, they can be safely removed. TAG=agy CONV=de3ef09d-a26c-4190-b578-4c993f807bdc --- .../bigtable/data/v2/BigtableDataClientTests.java | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientTests.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientTests.java index af1e95900754..e728b518f49d 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientTests.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientTests.java @@ -105,9 +105,7 @@ public void setUp() { mockStub = Mockito.mock(EnhancedBigtableStub.class, Mockito.withSettings().withoutAnnotations()); mockReadRowsCallable = - Mockito.mock( - ServerStreamingCallable.class, - Mockito.withSettings().withoutAnnotations().defaultAnswer(Answers.RETURNS_DEEP_STUBS)); + Mockito.mock(ServerStreamingCallable.class, Mockito.withSettings().withoutAnnotations()); mockReadRowCallable = Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); mockSampleRowKeysCallable = @@ -129,13 +127,9 @@ public void setUp() { mockPrepareQueryCallable = Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations()); mockGenerateInitialChangeStreamPartitionsCallable = - Mockito.mock( - ServerStreamingCallable.class, - Mockito.withSettings().withoutAnnotations().defaultAnswer(Answers.RETURNS_DEEP_STUBS)); + Mockito.mock(ServerStreamingCallable.class, Mockito.withSettings().withoutAnnotations()); mockReadChangeStreamCallable = - Mockito.mock( - ServerStreamingCallable.class, - Mockito.withSettings().withoutAnnotations().defaultAnswer(Answers.RETURNS_DEEP_STUBS)); + Mockito.mock(ServerStreamingCallable.class, Mockito.withSettings().withoutAnnotations()); bigtableDataClient = new BigtableDataClient(mockStub); }