From 9c1c8e90b0e02e26ea3c16def49bb7e07c2b04b1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Knut=20Olav=20L=C3=B8ite?= Date: Mon, 21 Jun 2021 03:22:18 +0200 Subject: [PATCH] feat: add support for instance processing units (#665) * feat: add support for instance processing units * docs: add sample for instance processing units * fix: remove commented code + use junit asserts * fix: remove Spanner snapshot reference * test: add tests for InstanceInfo * cleanup: fix formatting + tests * chore: fix formatting * test: fixes instanceinfo test Due to master merge the compilation was failing. Fixes the builder construction here. * refactor: adds default impl for processing units Adds default implementation for the InstanceInfo set processing units in order to avoid a breaking change. * samples: remove LCI samples for now Removes the LCI samples for now, because they won't compile. We will re-add them once the main implementation is released. * fix: addresses PR comments Co-authored-by: Thiago Tasca Nunes --- .../com/google/cloud/spanner/Instance.java | 9 +- .../spanner/InstanceAdminClientImpl.java | 6 +- .../google/cloud/spanner/InstanceInfo.java | 43 ++++- .../spanner/InstanceAdminClientImplTest.java | 148 +++++++++++++++++- .../cloud/spanner/InstanceInfoTest.java | 143 +++++++++++++++++ .../google/cloud/spanner/InstanceTest.java | 6 + .../spanner/SpannerStandaloneExamplesIT.java | 2 +- 7 files changed, 345 insertions(+), 12 deletions(-) create mode 100644 google-cloud-spanner/src/test/java/com/google/cloud/spanner/InstanceInfoTest.java diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/Instance.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/Instance.java index 9484bd0590..3b17ee52d2 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/Instance.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/Instance.java @@ -67,6 +67,12 @@ public Builder setNodeCount(int nodeCount) { return this; } + @Override + public Builder setProcessingUnits(int processingUnits) { + infoBuilder.setProcessingUnits(processingUnits); + return this; + } + @Override public Builder setState(State state) { infoBuilder.setState(state); @@ -198,7 +204,8 @@ static Instance fromProto( new Builder(instanceClient, dbClient, id) .setInstanceConfigId(InstanceConfigId.of(proto.getConfig())) .setDisplayName(proto.getDisplayName()) - .setNodeCount(proto.getNodeCount()); + .setNodeCount(proto.getNodeCount()) + .setProcessingUnits(proto.getProcessingUnits()); State state; switch (proto.getState()) { case STATE_UNSPECIFIED: diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/InstanceAdminClientImpl.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/InstanceAdminClientImpl.java index 4f25393b63..142540af66 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/InstanceAdminClientImpl.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/InstanceAdminClientImpl.java @@ -96,6 +96,9 @@ public InstanceConfig fromProto( @Override public OperationFuture createInstance(InstanceInfo instance) throws SpannerException { + Preconditions.checkArgument( + instance.getNodeCount() == 0 || instance.getProcessingUnits() == 0, + "Only one of nodeCount and processingUnits can be set when creating a new instance"); String projectName = PROJECT_NAME_TEMPLATE.instantiate("project", projectId); OperationFuture rawOperationFuture = @@ -158,7 +161,8 @@ public OperationFuture updateInstance( InstanceInfo instance, InstanceInfo.InstanceField... fieldsToUpdate) { FieldMask fieldMask = fieldsToUpdate.length == 0 - ? InstanceInfo.InstanceField.toFieldMask(InstanceInfo.InstanceField.values()) + ? InstanceInfo.InstanceField.toFieldMask( + InstanceInfo.InstanceField.defaultFieldsToUpdate(instance)) : InstanceInfo.InstanceField.toFieldMask(fieldsToUpdate); OperationFuture diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/InstanceInfo.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/InstanceInfo.java index 1892b914bb..fe47973bff 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/InstanceInfo.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/InstanceInfo.java @@ -33,8 +33,17 @@ public class InstanceInfo { public enum InstanceField implements FieldSelector { DISPLAY_NAME("display_name"), NODE_COUNT("node_count"), + PROCESSING_UNITS("processing_units"), LABELS("labels"); + static InstanceField[] defaultFieldsToUpdate(InstanceInfo info) { + if (info.getNodeCount() > 0) { + return new InstanceField[] {DISPLAY_NAME, NODE_COUNT, LABELS}; + } else { + return new InstanceField[] {DISPLAY_NAME, PROCESSING_UNITS, LABELS}; + } + } + private final String selector; InstanceField(String selector) { @@ -68,8 +77,22 @@ public abstract static class Builder { public abstract Builder setDisplayName(String displayName); + /** + * Sets the number of nodes for the instance. Exactly one of processing units or node count must + * be set when creating a new instance. + */ public abstract Builder setNodeCount(int nodeCount); + /** + * Sets the number of processing units for the instance. Exactly one of processing units or node + * count must be set when creating a new instance. Processing units must be between 1 and 999 + * (inclusive) when creating a new instance with node count = 0. Processing units from 1000 and + * up must always be a multiple of 1000 (that is equal to an integer number of nodes). + */ + public Builder setProcessingUnits(int processingUnits) { + throw new UnsupportedOperationException("Unimplemented"); + } + public abstract Builder setState(State state); public abstract Builder addLabel(String key, String value); @@ -84,6 +107,7 @@ static class BuilderImpl extends Builder { private InstanceConfigId configId; private String displayName; private int nodeCount; + private int processingUnits; private State state; private Map labels; @@ -97,6 +121,7 @@ static class BuilderImpl extends Builder { this.configId = instance.configId; this.displayName = instance.displayName; this.nodeCount = instance.nodeCount; + this.processingUnits = instance.processingUnits; this.state = instance.state; this.labels = new HashMap<>(instance.labels); } @@ -119,6 +144,12 @@ public BuilderImpl setNodeCount(int nodeCount) { return this; } + @Override + public BuilderImpl setProcessingUnits(int processingUnits) { + this.processingUnits = processingUnits; + return this; + } + @Override public BuilderImpl setState(State state) { this.state = state; @@ -147,6 +178,7 @@ public InstanceInfo build() { private final InstanceConfigId configId; private final String displayName; private final int nodeCount; + private final int processingUnits; private final State state; private final ImmutableMap labels; @@ -155,6 +187,7 @@ public InstanceInfo build() { this.configId = builder.configId; this.displayName = builder.displayName; this.nodeCount = builder.nodeCount; + this.processingUnits = builder.processingUnits; this.state = builder.state; this.labels = ImmutableMap.copyOf(builder.labels); } @@ -179,6 +212,11 @@ public int getNodeCount() { return nodeCount; } + /** Returns the number of processing units of the instance. */ + public int getProcessingUnits() { + return processingUnits; + } + /** Returns the current state of the instance. */ public State getState() { return state; @@ -200,6 +238,7 @@ public String toString() { .add("configName", configId == null ? null : configId.getName()) .add("displayName", displayName) .add("nodeCount", nodeCount) + .add("processingUnits", processingUnits) .add("state", state) .add("labels", labels) .toString(); @@ -218,13 +257,14 @@ public boolean equals(Object o) { && Objects.equals(configId, that.configId) && Objects.equals(displayName, that.displayName) && nodeCount == that.nodeCount + && processingUnits == that.processingUnits && state == that.state && Objects.equals(labels, that.labels); } @Override public int hashCode() { - return Objects.hash(id, configId, displayName, nodeCount, state, labels); + return Objects.hash(id, configId, displayName, nodeCount, processingUnits, state, labels); } com.google.spanner.admin.instance.v1.Instance toProto() { @@ -232,6 +272,7 @@ com.google.spanner.admin.instance.v1.Instance toProto() { com.google.spanner.admin.instance.v1.Instance.newBuilder() .setName(getId().getName()) .setNodeCount(getNodeCount()) + .setProcessingUnits(getProcessingUnits()) .putAllLabels(getLabels()); if (getDisplayName() != null) { builder.setDisplayName(getDisplayName()); diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/InstanceAdminClientImplTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/InstanceAdminClientImplTest.java index c981da7309..0df869de67 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/InstanceAdminClientImplTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/InstanceAdminClientImplTest.java @@ -17,6 +17,9 @@ package com.google.cloud.spanner; import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static org.mockito.MockitoAnnotations.initMocks; @@ -98,6 +101,15 @@ private com.google.spanner.admin.instance.v1.Instance getInstanceProto() { .setConfig(CONFIG_NAME) .setName(INSTANCE_NAME) .setNodeCount(1) + .setProcessingUnits(1000) + .build(); + } + + private com.google.spanner.admin.instance.v1.Instance getInstanceProtoWithProcessingUnits() { + return com.google.spanner.admin.instance.v1.Instance.newBuilder() + .setConfig(CONFIG_NAME) + .setName(INSTANCE_NAME) + .setProcessingUnits(10) .build(); } @@ -105,7 +117,8 @@ private com.google.spanner.admin.instance.v1.Instance getAnotherInstanceProto() return com.google.spanner.admin.instance.v1.Instance.newBuilder() .setConfig(CONFIG_NAME) .setName(INSTANCE_NAME2) - .setNodeCount(1) + .setNodeCount(2) + .setProcessingUnits(2000) .build(); } @@ -115,7 +128,10 @@ public void createInstance() throws Exception { rawOperationFuture = OperationFutureUtil.immediateOperationFuture( "createInstance", getInstanceProto(), CreateInstanceMetadata.getDefaultInstance()); - when(rpc.createInstance("projects/" + PROJECT_ID, INSTANCE_ID, getInstanceProto())) + when(rpc.createInstance( + "projects/" + PROJECT_ID, + INSTANCE_ID, + getInstanceProto().toBuilder().setProcessingUnits(0).build())) .thenReturn(rawOperationFuture); OperationFuture op = client.createInstance( @@ -128,9 +144,50 @@ public void createInstance() throws Exception { } @Test - public void getInstance() { + public void testCreateInstanceWithProcessingUnits() throws Exception { + OperationFuture + rawOperationFuture = + OperationFutureUtil.immediateOperationFuture( + "createInstance", + getInstanceProtoWithProcessingUnits(), + CreateInstanceMetadata.getDefaultInstance()); + when(rpc.createInstance( + "projects/" + PROJECT_ID, INSTANCE_ID, getInstanceProtoWithProcessingUnits())) + .thenReturn(rawOperationFuture); + OperationFuture operation = + client.createInstance( + InstanceInfo.newBuilder(InstanceId.of(PROJECT_ID, INSTANCE_ID)) + .setInstanceConfigId(InstanceConfigId.of(PROJECT_ID, CONFIG_ID)) + .setProcessingUnits(10) + .build()); + assertTrue(operation.isDone()); + assertEquals(INSTANCE_NAME, operation.get().getId().getName()); + } + + @Test + public void testCreateInstanceWithBothNodeCountAndProcessingUnits() throws Exception { + try { + client.createInstance( + InstanceInfo.newBuilder(InstanceId.of(PROJECT_ID, INSTANCE_ID)) + .setInstanceConfigId(InstanceConfigId.of(PROJECT_ID, CONFIG_ID)) + .setNodeCount(1) + .setProcessingUnits(100) + .build()); + fail("missing expected exception"); + } catch (IllegalArgumentException e) { + assertTrue( + e.getMessage() + .contains( + "Only one of nodeCount and processingUnits can be set when creating a new instance")); + } + } + + @Test + public void testGetInstance() { when(rpc.getInstance(INSTANCE_NAME)).thenReturn(getInstanceProto()); - assertThat(client.getInstance(INSTANCE_ID).getId().getName()).isEqualTo(INSTANCE_NAME); + Instance instance = client.getInstance(INSTANCE_ID); + assertEquals(INSTANCE_NAME, instance.getId().getName()); + assertEquals(1000, instance.getProcessingUnits()); } @Test @@ -165,7 +222,80 @@ public void updateInstanceMetadata() throws Exception { } @Test - public void listInstances() { + public void testUpdateInstanceProcessingUnits() throws Exception { + com.google.spanner.admin.instance.v1.Instance instance = + com.google.spanner.admin.instance.v1.Instance.newBuilder() + .setName(INSTANCE_NAME) + .setConfig(CONFIG_NAME) + .setProcessingUnits(10) + .build(); + OperationFuture + rawOperationFuture = + OperationFutureUtil.immediateOperationFuture( + "updateInstance", + getInstanceProtoWithProcessingUnits(), + UpdateInstanceMetadata.getDefaultInstance()); + when(rpc.updateInstance(instance, FieldMask.newBuilder().addPaths("processing_units").build())) + .thenReturn(rawOperationFuture); + InstanceInfo instanceInfo = + InstanceInfo.newBuilder(InstanceId.of(INSTANCE_NAME)) + .setInstanceConfigId(InstanceConfigId.of(CONFIG_NAME)) + .setProcessingUnits(10) + .build(); + OperationFuture operationWithFieldMask = + client.updateInstance(instanceInfo, InstanceInfo.InstanceField.PROCESSING_UNITS); + assertTrue(operationWithFieldMask.isDone()); + assertEquals(INSTANCE_NAME, operationWithFieldMask.get().getId().getName()); + + when(rpc.updateInstance( + instance, + FieldMask.newBuilder() + .addAllPaths(Arrays.asList("display_name", "processing_units", "labels")) + .build())) + .thenReturn(rawOperationFuture); + OperationFuture operation = + client.updateInstance(instanceInfo); + assertTrue(operation.isDone()); + assertEquals(INSTANCE_NAME, operation.get().getId().getName()); + } + + @Test + public void testUpdateInstanceWithNodeCountAndProcessingUnits() throws Exception { + com.google.spanner.admin.instance.v1.Instance instance = + com.google.spanner.admin.instance.v1.Instance.newBuilder() + .setName(INSTANCE_NAME) + .setConfig(CONFIG_NAME) + .setNodeCount(3) + .setProcessingUnits(3000) + .build(); + OperationFuture + rawOperationFuture = + OperationFutureUtil.immediateOperationFuture( + "updateInstance", + getInstanceProtoWithProcessingUnits(), + UpdateInstanceMetadata.getDefaultInstance()); + // node_count should take precedence over processing_units when node_count>0 and no specific + // field mask is set by the caller. + when(rpc.updateInstance( + instance, + FieldMask.newBuilder() + .addAllPaths(Arrays.asList("display_name", "node_count", "labels")) + .build())) + .thenReturn(rawOperationFuture); + InstanceInfo instanceInfo = + InstanceInfo.newBuilder(InstanceId.of(INSTANCE_NAME)) + .setInstanceConfigId(InstanceConfigId.of(CONFIG_NAME)) + .setNodeCount(3) + .setProcessingUnits(3000) + .build(); + OperationFuture operationWithFieldMask = + client.updateInstance(instanceInfo); + assertTrue(operationWithFieldMask.isDone()); + assertEquals(INSTANCE_NAME, operationWithFieldMask.get().getId().getName()); + } + + @Test + public void testListInstances() { String nextToken = "token"; String filter = "env:dev"; when(rpc.listInstances(1, null, filter)) @@ -175,9 +305,11 @@ public void listInstances() { List instances = Lists.newArrayList( client.listInstances(Options.pageSize(1), Options.filter(filter)).iterateAll()); - assertThat(instances.get(0).getId().getName()).isEqualTo(INSTANCE_NAME); - assertThat(instances.get(1).getId().getName()).isEqualTo(INSTANCE_NAME2); - assertThat(instances.size()).isEqualTo(2); + assertEquals(INSTANCE_NAME, instances.get(0).getId().getName()); + assertEquals(1000, instances.get(0).getProcessingUnits()); + assertEquals(INSTANCE_NAME2, instances.get(1).getId().getName()); + assertEquals(2000, instances.get(1).getProcessingUnits()); + assertEquals(2, instances.size()); } @Test diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/InstanceInfoTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/InstanceInfoTest.java new file mode 100644 index 0000000000..c715233efb --- /dev/null +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/InstanceInfoTest.java @@ -0,0 +1,143 @@ +/* + * Copyright 2021 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.cloud.spanner; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class InstanceInfoTest { + + @Test + public void testEmptyBuilder() { + InstanceId id = InstanceId.of("test-project", "test-instance"); + InstanceInfo.Builder builder = InstanceInfo.newBuilder(id); + InstanceInfo info = builder.build(); + assertNull(info.getDisplayName()); + assertEquals(InstanceId.of("test-project", "test-instance"), info.getId()); + assertNull(info.getInstanceConfigId()); + assertNull(info.getState()); + assertEquals(0, info.getNodeCount()); + assertEquals(0, info.getProcessingUnits()); + assertTrue(info.getLabels().isEmpty()); + } + + @Test + public void testBuildInstanceInfo() { + InstanceId id = new InstanceId("test-project", "test-instance"); + InstanceConfigId configId = new InstanceConfigId("test-project", "test-instance-config"); + InstanceInfo info = + InstanceInfo.newBuilder(id) + .setInstanceConfigId(configId) + .setDisplayName("test instance") + .setNodeCount(1) + .setProcessingUnits(2000) + .setState(InstanceInfo.State.READY) + .addLabel("env", "prod") + .addLabel("region", "us") + .build(); + assertThat(info.getId()).isEqualTo(id); + assertThat(info.getInstanceConfigId()).isEqualTo(configId); + assertThat(info.getDisplayName()).isEqualTo("test instance"); + assertThat(info.getNodeCount()).isEqualTo(1); + assertThat(info.getProcessingUnits()).isEqualTo(2000); + assertThat(info.getState()).isEqualTo(InstanceInfo.State.READY); + assertThat(info.getLabels()).containsExactly("env", "prod", "region", "us"); + + info = info.toBuilder().setDisplayName("new test instance").build(); + assertThat(info.getId()).isEqualTo(id); + assertThat(info.getInstanceConfigId()).isEqualTo(configId); + assertThat(info.getDisplayName()).isEqualTo("new test instance"); + assertThat(info.getNodeCount()).isEqualTo(1); + assertThat(info.getProcessingUnits()).isEqualTo(2000); + assertThat(info.getState()).isEqualTo(InstanceInfo.State.READY); + assertThat(info.getLabels()).containsExactly("env", "prod", "region", "us"); + } + + @Test + public void testToBuilder() { + InstanceId id = new InstanceId("test-project", "test-instance"); + InstanceConfigId configId = new InstanceConfigId("test-project", "test-instance-config"); + InstanceInfo info = + InstanceInfo.newBuilder(id) + .setInstanceConfigId(configId) + .setDisplayName("test instance") + .setNodeCount(1) + .setProcessingUnits(2000) + .setState(InstanceInfo.State.READY) + .addLabel("env", "prod") + .addLabel("region", "us") + .build(); + + InstanceInfo rebuilt = info.toBuilder().setDisplayName("new test instance").build(); + assertThat(rebuilt.getId()).isEqualTo(id); + assertThat(rebuilt.getInstanceConfigId()).isEqualTo(configId); + assertThat(rebuilt.getDisplayName()).isEqualTo("new test instance"); + assertThat(rebuilt.getNodeCount()).isEqualTo(1); + assertThat(rebuilt.getProcessingUnits()).isEqualTo(2000); + assertThat(rebuilt.getState()).isEqualTo(InstanceInfo.State.READY); + assertThat(rebuilt.getLabels()).containsExactly("env", "prod", "region", "us"); + } + + @Test + public void testEquals() { + InstanceId id = new InstanceId("test-project", "test-instance"); + InstanceConfigId configId1 = new InstanceConfigId("test-project", "test-instance-config"); + InstanceConfigId configId2 = new InstanceConfigId("test-project", "other-test-instance-config"); + + InstanceInfo instance = + InstanceInfo.newBuilder(id) + .setInstanceConfigId(configId1) + .setDisplayName("test instance") + .setNodeCount(1) + .setProcessingUnits(2000) + .setState(InstanceInfo.State.READY) + .addLabel("env", "prod") + .addLabel("region", "us") + .build(); + InstanceInfo instance2 = + InstanceInfo.newBuilder(id) + .setInstanceConfigId(configId1) + .setDisplayName("test instance") + .setNodeCount(1) + .setProcessingUnits(2000) + .setState(InstanceInfo.State.READY) + .addLabel("region", "us") + .addLabel("env", "prod") + .build(); + InstanceInfo instance3 = + InstanceInfo.newBuilder(id) + .setInstanceConfigId(configId2) + .setDisplayName("other test instance") + .setNodeCount(1) + .setProcessingUnits(2000) + .setState(InstanceInfo.State.READY) + .addLabel("env", "prod") + .build(); + EqualsTester tester = new EqualsTester(); + tester.addEqualityGroup(instance, instance2); + tester.addEqualityGroup(instance3); + tester.testEquals(); + } +} diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/InstanceTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/InstanceTest.java index 86c39f59ba..87378caeb4 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/InstanceTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/InstanceTest.java @@ -52,6 +52,7 @@ public void buildInstance() { .setInstanceConfigId(configId) .setDisplayName("test instance") .setNodeCount(1) + .setProcessingUnits(2000) .setState(InstanceInfo.State.READY) .addLabel("env", "prod") .addLabel("region", "us") @@ -60,6 +61,7 @@ public void buildInstance() { assertThat(instance.getInstanceConfigId()).isEqualTo(configId); assertThat(instance.getDisplayName()).isEqualTo("test instance"); assertThat(instance.getNodeCount()).isEqualTo(1); + assertThat(instance.getProcessingUnits()).isEqualTo(2000); assertThat(instance.getState()).isEqualTo(InstanceInfo.State.READY); assertThat(instance.getLabels()).containsExactly("env", "prod", "region", "us"); @@ -68,6 +70,7 @@ public void buildInstance() { assertThat(instance.getInstanceConfigId()).isEqualTo(configId); assertThat(instance.getDisplayName()).isEqualTo("new test instance"); assertThat(instance.getNodeCount()).isEqualTo(1); + assertThat(instance.getProcessingUnits()).isEqualTo(2000); assertThat(instance.getState()).isEqualTo(InstanceInfo.State.READY); assertThat(instance.getLabels()).containsExactly("env", "prod", "region", "us"); } @@ -82,6 +85,7 @@ public void equality() { .setInstanceConfigId(configId) .setDisplayName("test instance") .setNodeCount(1) + .setProcessingUnits(2000) .setState(InstanceInfo.State.READY) .addLabel("env", "prod") .addLabel("region", "us") @@ -91,6 +95,7 @@ public void equality() { .setInstanceConfigId(configId) .setDisplayName("test instance") .setNodeCount(1) + .setProcessingUnits(2000) .setState(InstanceInfo.State.READY) .addLabel("region", "us") .addLabel("env", "prod") @@ -100,6 +105,7 @@ public void equality() { .setInstanceConfigId(configId) .setDisplayName("test instance") .setNodeCount(1) + .setProcessingUnits(2000) .setState(InstanceInfo.State.READY) .addLabel("env", "prod") .build(); diff --git a/samples/snippets/src/test/java/com/example/spanner/SpannerStandaloneExamplesIT.java b/samples/snippets/src/test/java/com/example/spanner/SpannerStandaloneExamplesIT.java index 2b3e016d1e..cccf45ada3 100644 --- a/samples/snippets/src/test/java/com/example/spanner/SpannerStandaloneExamplesIT.java +++ b/samples/snippets/src/test/java/com/example/spanner/SpannerStandaloneExamplesIT.java @@ -199,4 +199,4 @@ public void queryWithNumericParameter_shouldReturnResults() { runExample(() -> QueryWithNumericParameterSample.queryWithNumericParameter(client)); assertThat(out).contains("4 35000"); } -} \ No newline at end of file +}