Skip to content

Commit 90c2107

Browse files
lqiu96lqiu96
authored
test(bigtable): fix remaining JSpecify CI issues on Java 8 (#13834)
1 parent ded9138 commit 90c2107

17 files changed

Lines changed: 140 additions & 71 deletions

‎java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/BigtableTableAdminClientTests.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1749,7 +1749,7 @@ public void testAwaitOptimizeRestoredTable() throws Exception {
17491749

17501750
// 4. Mock the Stub's behavior (resuming the Optimize Op)
17511751
OperationFuture<Empty, OptimizeRestoredTableMetadata> mockOptimizeOp =
1752-
Mockito.mock(OperationFuture.class);
1752+
Mockito.mock(OperationFuture.class, Mockito.withSettings().withoutAnnotations());
17531753
Mockito.when(mockOptimizeRestoredTableCallable.resumeFutureCall(optimizeToken))
17541754
.thenReturn(mockOptimizeOp);
17551755

‎java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/BigtableTableAdminSettingsTest.java‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -65,7 +65,8 @@ public void testMissingInstanceName() {
6565

6666
@Test
6767
public void testCredentials() throws IOException {
68-
CredentialsProvider credentialsProvider = Mockito.mock(CredentialsProvider.class);
68+
CredentialsProvider credentialsProvider =
69+
Mockito.mock(CredentialsProvider.class, Mockito.withSettings().withoutAnnotations());
6970

7071
BigtableTableAdminSettings settings =
7172
BigtableTableAdminSettings.newBuilder()

‎java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/stub/AwaitConsistencyCallableTest.java‎

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -43,7 +43,6 @@
4343
import org.junit.runner.RunWith;
4444
import org.junit.runners.JUnit4;
4545
import org.mockito.ArgumentMatchers;
46-
import org.mockito.Mock;
4746
import org.mockito.Mockito;
4847
import org.mockito.junit.MockitoJUnit;
4948
import org.mockito.junit.MockitoRule;
@@ -63,11 +62,9 @@ public class AwaitConsistencyCallableTest {
6362
private static final TableAdminRequestContext REQUEST_CONTEXT =
6463
TableAdminRequestContext.create(PROJECT_ID, INSTANCE_ID);
6564

66-
@Mock
6765
private UnaryCallable<GenerateConsistencyTokenRequest, GenerateConsistencyTokenResponse>
6866
mockGenerateConsistencyTokenCallable;
6967

70-
@Mock
7168
private UnaryCallable<CheckConsistencyRequest, CheckConsistencyResponse>
7269
mockCheckConsistencyCallable;
7370

@@ -77,6 +74,11 @@ public class AwaitConsistencyCallableTest {
7774

7875
@Before
7976
public void setUp() {
77+
mockGenerateConsistencyTokenCallable =
78+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
79+
mockCheckConsistencyCallable =
80+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
81+
8082
ClientContext clientContext =
8183
ClientContext.newBuilder().setDefaultCallContext(CALL_CONTEXT).build();
8284

‎java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/admin/v2/stub/AwaitConsistencyCallableV2Test.java‎

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,6 @@
4242
import org.junit.runner.RunWith;
4343
import org.junit.runners.JUnit4;
4444
import org.mockito.ArgumentMatchers;
45-
import org.mockito.Mock;
4645
import org.mockito.Mockito;
4746
import org.mockito.junit.MockitoJUnit;
4847
import org.mockito.junit.MockitoRule;
@@ -59,18 +58,21 @@ public class AwaitConsistencyCallableV2Test {
5958
private static final TableName TABLE_NAME = TableName.of(PROJECT_ID, INSTANCE_ID, TABLE_ID);
6059
private static final ApiCallContext CALL_CONTEXT = FakeCallContext.createDefault();
6160

62-
@Mock
6361
private UnaryCallable<GenerateConsistencyTokenRequest, GenerateConsistencyTokenResponse>
6462
mockGenerateConsistencyTokenCallable;
6563

66-
@Mock
6764
private UnaryCallable<CheckConsistencyRequest, CheckConsistencyResponse>
6865
mockCheckConsistencyCallable;
6966

7067
private AwaitConsistencyCallableV2 awaitConsistencyCallable;
7168

7269
@Before
7370
public void setUp() {
71+
mockGenerateConsistencyTokenCallable =
72+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
73+
mockCheckConsistencyCallable =
74+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
75+
7476
RetrySettings retrySettings =
7577
RetrySettings.newBuilder()
7678
.setTotalTimeout(Duration.ofMillis(100))

‎java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientFactoryTest.java‎

Lines changed: 24 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -134,27 +134,42 @@ public void transportTerminated(Attributes transportAttrs) {
134134
transportChannelProvider =
135135
Mockito.mock(
136136
TransportChannelProvider.class,
137-
new BuilderAnswer<>(
138-
TransportChannelProvider.class,
139-
builder.stubSettings().getTransportChannelProvider()));
137+
Mockito.withSettings()
138+
.withoutAnnotations()
139+
.defaultAnswer(
140+
new BuilderAnswer<>(
141+
TransportChannelProvider.class,
142+
builder.stubSettings().getTransportChannelProvider())));
140143

141144
credentialsProvider =
142145
Mockito.mock(
143146
CredentialsProvider.class,
144-
new BuilderAnswer<>(
145-
CredentialsProvider.class, builder.stubSettings().getCredentialsProvider()));
147+
Mockito.withSettings()
148+
.withoutAnnotations()
149+
.defaultAnswer(
150+
new BuilderAnswer<>(
151+
CredentialsProvider.class,
152+
builder.stubSettings().getCredentialsProvider())));
146153

147154
executorProvider =
148155
Mockito.mock(
149156
ExecutorProvider.class,
150-
new BuilderAnswer<>(
151-
ExecutorProvider.class, builder.stubSettings().getBackgroundExecutorProvider()));
157+
Mockito.withSettings()
158+
.withoutAnnotations()
159+
.defaultAnswer(
160+
new BuilderAnswer<>(
161+
ExecutorProvider.class,
162+
builder.stubSettings().getBackgroundExecutorProvider())));
152163

153164
watchdogProvider =
154165
Mockito.mock(
155166
WatchdogProvider.class,
156-
new BuilderAnswer<>(
157-
WatchdogProvider.class, builder.stubSettings().getStreamWatchdogProvider()));
167+
Mockito.withSettings()
168+
.withoutAnnotations()
169+
.defaultAnswer(
170+
new BuilderAnswer<>(
171+
WatchdogProvider.class,
172+
builder.stubSettings().getStreamWatchdogProvider())));
158173

159174
ApiClock apiClock = builder.stubSettings().getClock();
160175

‎java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/BigtableDataClientTests.java‎

Lines changed: 49 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,6 @@
5959
import org.junit.runner.RunWith;
6060
import org.junit.runners.JUnit4;
6161
import org.mockito.ArgumentMatchers;
62-
import org.mockito.Mock;
6362
import org.mockito.Mockito;
6463
import org.mockito.junit.MockitoJUnit;
6564
import org.mockito.junit.MockitoRule;
@@ -76,36 +75,62 @@ public class BigtableDataClientTests {
7675

7776
@Rule public MockitoRule mockitoRule = MockitoJUnit.rule().strictness(Strictness.WARN);
7877

79-
@Mock private EnhancedBigtableStub mockStub;
78+
private EnhancedBigtableStub mockStub;
8079

81-
@Mock private ServerStreamingCallable<Query, Row> mockReadRowsCallable;
80+
private ServerStreamingCallable<Query, Row> mockReadRowsCallable;
8281

83-
@Mock private UnaryCallable<Query, Row> mockReadRowCallable;
84-
@Mock private UnaryCallable<String, List<KeyOffset>> mockSampleRowKeysCallable;
82+
private UnaryCallable<Query, Row> mockReadRowCallable;
83+
private UnaryCallable<String, List<KeyOffset>> mockSampleRowKeysCallable;
8584

86-
@Mock
8785
private UnaryCallable<SampleRowKeysRequest, List<KeyOffset>> mockSampleRowKeysCallableWithRequest;
8886

89-
@Mock private UnaryCallable<RowMutation, Void> mockMutateRowCallable;
90-
@Mock private UnaryCallable<ConditionalRowMutation, Boolean> mockCheckAndMutateRowCallable;
91-
@Mock private UnaryCallable<ReadModifyWriteRow, Row> mockReadModifyWriteRowCallable;
92-
@Mock private UnaryCallable<BulkMutation, Void> mockBulkMutateRowsCallable;
93-
@Mock private Batcher<RowMutationEntry, Void> mockBulkMutationBatcher;
94-
@Mock private Batcher<ByteString, Row> mockBulkReadRowsBatcher;
95-
@Mock private UnaryCallable<PrepareQueryRequest, PrepareResponse> mockPrepareQueryCallable;
87+
private UnaryCallable<RowMutation, Void> mockMutateRowCallable;
88+
private UnaryCallable<ConditionalRowMutation, Boolean> mockCheckAndMutateRowCallable;
89+
private UnaryCallable<ReadModifyWriteRow, Row> mockReadModifyWriteRowCallable;
90+
private UnaryCallable<BulkMutation, Void> mockBulkMutateRowsCallable;
91+
private Batcher<RowMutationEntry, Void> mockBulkMutationBatcher;
92+
private Batcher<ByteString, Row> mockBulkReadRowsBatcher;
93+
private UnaryCallable<PrepareQueryRequest, PrepareResponse> mockPrepareQueryCallable;
9694

97-
@Mock
9895
private ServerStreamingCallable<String, ByteStringRange>
9996
mockGenerateInitialChangeStreamPartitionsCallable;
100-
101-
@Mock
10297
private ServerStreamingCallable<ReadChangeStreamQuery, ChangeStreamRecord>
10398
mockReadChangeStreamCallable;
10499

105100
private BigtableDataClient bigtableDataClient;
106101

107102
@Before
103+
@SuppressWarnings("unchecked")
108104
public void setUp() {
105+
mockStub =
106+
Mockito.mock(EnhancedBigtableStub.class, Mockito.withSettings().withoutAnnotations());
107+
mockReadRowsCallable =
108+
Mockito.mock(ServerStreamingCallable.class, Mockito.withSettings().withoutAnnotations());
109+
mockReadRowCallable =
110+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
111+
mockSampleRowKeysCallable =
112+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
113+
mockSampleRowKeysCallableWithRequest =
114+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
115+
mockMutateRowCallable =
116+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
117+
mockCheckAndMutateRowCallable =
118+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
119+
mockReadModifyWriteRowCallable =
120+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
121+
mockBulkMutateRowsCallable =
122+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
123+
mockBulkMutationBatcher =
124+
Mockito.mock(Batcher.class, Mockito.withSettings().withoutAnnotations());
125+
mockBulkReadRowsBatcher =
126+
Mockito.mock(Batcher.class, Mockito.withSettings().withoutAnnotations());
127+
mockPrepareQueryCallable =
128+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
129+
mockGenerateInitialChangeStreamPartitionsCallable =
130+
Mockito.mock(ServerStreamingCallable.class, Mockito.withSettings().withoutAnnotations());
131+
mockReadChangeStreamCallable =
132+
Mockito.mock(ServerStreamingCallable.class, Mockito.withSettings().withoutAnnotations());
133+
109134
bigtableDataClient = new BigtableDataClient(mockStub);
110135
}
111136

@@ -597,7 +622,8 @@ public void proxyReadRowsAsyncTest() {
597622

598623
Query query = Query.create(TableId.of("fake-table"));
599624
@SuppressWarnings("unchecked")
600-
ResponseObserver<Row> mockObserver = Mockito.mock(ResponseObserver.class);
625+
ResponseObserver<Row> mockObserver =
626+
Mockito.mock(ResponseObserver.class, Mockito.withSettings().withoutAnnotations());
601627
bigtableDataClient.readRowsAsync(query, mockObserver);
602628

603629
Mockito.verify(mockReadRowsCallable).call(query, mockObserver);
@@ -609,7 +635,8 @@ public void proxyReadRowsOnAuthorizedViewAsyncTest() {
609635

610636
Query query = Query.create(AuthorizedViewId.of("fake-table", "fake-authorized-view"));
611637
@SuppressWarnings("unchecked")
612-
ResponseObserver<Row> mockObserver = Mockito.mock(ResponseObserver.class);
638+
ResponseObserver<Row> mockObserver =
639+
Mockito.mock(ResponseObserver.class, Mockito.withSettings().withoutAnnotations());
613640
bigtableDataClient.readRowsAsync(query, mockObserver);
614641

615642
Mockito.verify(mockReadRowsCallable).call(query, mockObserver);
@@ -631,7 +658,8 @@ public void proxyGenerateInitialChangeStreamPartitionsAsyncTest() {
631658
.thenReturn(mockGenerateInitialChangeStreamPartitionsCallable);
632659

633660
@SuppressWarnings("unchecked")
634-
ResponseObserver<ByteStringRange> mockObserver = Mockito.mock(ResponseObserver.class);
661+
ResponseObserver<ByteStringRange> mockObserver =
662+
Mockito.mock(ResponseObserver.class, Mockito.withSettings().withoutAnnotations());
635663
bigtableDataClient.generateInitialChangeStreamPartitionsAsync("fake-table", mockObserver);
636664

637665
Mockito.verify(mockGenerateInitialChangeStreamPartitionsCallable)
@@ -653,7 +681,8 @@ public void proxyReadChangeStreamAsyncTest() {
653681
Mockito.when(mockStub.readChangeStreamCallable()).thenReturn(mockReadChangeStreamCallable);
654682

655683
@SuppressWarnings("unchecked")
656-
ResponseObserver<ChangeStreamRecord> mockObserver = Mockito.mock(ResponseObserver.class);
684+
ResponseObserver<ChangeStreamRecord> mockObserver =
685+
Mockito.mock(ResponseObserver.class, Mockito.withSettings().withoutAnnotations());
657686
ReadChangeStreamQuery query = ReadChangeStreamQuery.create("fake-table");
658687
bigtableDataClient.readChangeStreamAsync(query, mockObserver);
659688

‎java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/MetricsIsolationTest.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -107,7 +107,7 @@ void setUp() {
107107
new MetricsImpl(
108108
registry,
109109
clientInfo,
110-
Mockito.mock(ApiTracerFactory.class),
110+
Mockito.mock(ApiTracerFactory.class, Mockito.withSettings().withoutAnnotations()),
111111
internalOtel,
112112
userOtel,
113113
Mockito.mock(Tagger.class),

‎java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/exporter/BigtableCloudMonitoringExporterTest.java‎

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,6 @@
1717

1818
import static com.google.common.truth.Truth.assertThat;
1919
import static org.mockito.ArgumentMatchers.any;
20-
import static org.mockito.Mockito.mock;
2120
import static org.mockito.Mockito.times;
2221
import static org.mockito.Mockito.verify;
2322
import static org.mockito.Mockito.when;
@@ -144,7 +143,8 @@ public void testExportingSumData() {
144143
ArgumentCaptor<CreateTimeSeriesRequest> argumentCaptor =
145144
ArgumentCaptor.forClass(CreateTimeSeriesRequest.class);
146145

147-
UnaryCallable<CreateTimeSeriesRequest, Empty> mockCallable = mock(UnaryCallable.class);
146+
UnaryCallable<CreateTimeSeriesRequest, Empty> mockCallable =
147+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
148148
when(mockMetricServiceStub.createServiceTimeSeriesCallable()).thenReturn(mockCallable);
149149
ApiFuture<Empty> future = ApiFutures.immediateFuture(Empty.getDefaultInstance());
150150
when(mockCallable.futureCall(argumentCaptor.capture())).thenReturn(future);
@@ -201,7 +201,8 @@ public void testExportingHistogramData() {
201201
ArgumentCaptor<CreateTimeSeriesRequest> argumentCaptor =
202202
ArgumentCaptor.forClass(CreateTimeSeriesRequest.class);
203203

204-
UnaryCallable<CreateTimeSeriesRequest, Empty> mockCallable = mock(UnaryCallable.class);
204+
UnaryCallable<CreateTimeSeriesRequest, Empty> mockCallable =
205+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
205206
when(mockMetricServiceStub.createServiceTimeSeriesCallable()).thenReturn(mockCallable);
206207
ApiFuture<Empty> future = ApiFutures.immediateFuture(Empty.getDefaultInstance());
207208
when(mockCallable.futureCall(argumentCaptor.capture())).thenReturn(future);
@@ -267,7 +268,8 @@ public void testExportingSumDataInBatches() {
267268
ArgumentCaptor<CreateTimeSeriesRequest> argumentCaptor =
268269
ArgumentCaptor.forClass(CreateTimeSeriesRequest.class);
269270

270-
UnaryCallable<CreateTimeSeriesRequest, Empty> mockCallable = mock(UnaryCallable.class);
271+
UnaryCallable<CreateTimeSeriesRequest, Empty> mockCallable =
272+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
271273
when(mockMetricServiceStub.createServiceTimeSeriesCallable()).thenReturn(mockCallable);
272274
ApiFuture<Empty> future = ApiFutures.immediateFuture(Empty.getDefaultInstance());
273275
when(mockCallable.futureCall(argumentCaptor.capture())).thenReturn(future);
@@ -352,7 +354,8 @@ public void testTimeSeriesForMetricWithGceOrGkeResource() {
352354
ArgumentCaptor<CreateTimeSeriesRequest> argumentCaptor =
353355
ArgumentCaptor.forClass(CreateTimeSeriesRequest.class);
354356

355-
UnaryCallable<CreateTimeSeriesRequest, Empty> mockCallable = mock(UnaryCallable.class);
357+
UnaryCallable<CreateTimeSeriesRequest, Empty> mockCallable =
358+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
356359
when(mockMetricServiceStub.createServiceTimeSeriesCallable()).thenReturn(mockCallable);
357360
ApiFuture<Empty> future = ApiFutures.immediateFuture(Empty.getDefaultInstance());
358361
when(mockCallable.futureCall(argumentCaptor.capture())).thenReturn(future);
@@ -430,7 +433,8 @@ public void testExportingToMultipleProjects() {
430433
ArgumentCaptor<CreateTimeSeriesRequest> argumentCaptor =
431434
ArgumentCaptor.forClass(CreateTimeSeriesRequest.class);
432435

433-
UnaryCallable<CreateTimeSeriesRequest, Empty> mockCallable = mock(UnaryCallable.class);
436+
UnaryCallable<CreateTimeSeriesRequest, Empty> mockCallable =
437+
Mockito.mock(UnaryCallable.class, Mockito.withSettings().withoutAnnotations());
434438
when(mockMetricServiceStub.createServiceTimeSeriesCallable()).thenReturn(mockCallable);
435439
ApiFuture<Empty> future = ApiFutures.immediateFuture(Empty.getDefaultInstance());
436440
when(mockCallable.futureCall(any())).thenReturn(future);

‎java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/csm/opencensus/MetricsTracerTest.java‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -73,7 +73,6 @@
7373
import org.junit.runner.RunWith;
7474
import org.junit.runners.JUnit4;
7575
import org.mockito.Answers;
76-
import org.mockito.Mock;
7776
import org.mockito.Mockito;
7877
import org.mockito.junit.MockitoJUnit;
7978
import org.mockito.junit.MockitoRule;
@@ -104,7 +103,6 @@ public class MetricsTracerTest {
104103

105104
private Server server;
106105

107-
@Mock(answer = Answers.CALLS_REAL_METHODS)
108106
private BigtableGrpc.BigtableImplBase mockService;
109107

110108
private final StatsComponent localStats = new SimpleStatsComponent();
@@ -113,6 +111,10 @@ public class MetricsTracerTest {
113111

114112
@Before
115113
public void setUp() throws Exception {
114+
mockService =
115+
Mockito.mock(
116+
BigtableGrpc.BigtableImplBase.class,
117+
Mockito.withSettings().withoutAnnotations().defaultAnswer(Answers.CALLS_REAL_METHODS));
116118
server = FakeServiceBuilder.create(mockService).start();
117119

118120
com.google.cloud.bigtable.data.v2.stub.metrics.RpcViews.registerBigtableClientViews(
@@ -414,7 +416,8 @@ public void testBatchReadRowsThrottledTime() throws Exception {
414416

415417
@Test
416418
public void testBatchMutateRowsThrottledTime() throws Exception {
417-
FlowController flowController = Mockito.mock(FlowController.class);
419+
FlowController flowController =
420+
Mockito.mock(FlowController.class, Mockito.withSettings().withoutAnnotations());
418421
MutateRowsBatchingDescriptor batchingDescriptor = new MutateRowsBatchingDescriptor();
419422

420423
// Mock throttling

0 commit comments

Comments
 (0)