warnings() {
+ return warnings;
+ }
+
+ /**
+ * Returns the HTTP error status code that was returned, if the operation failed. For example, a
+ * {@code 404} means the resource was not found.
+ */
+ public Integer httpErrorStatusCode() {
+ return httpErrorStatusCode;
+ }
+
+ /**
+ * Returns the the HTTP error message that was returned, if the operation failed. For example, a
+ * {@code NOT FOUND} message is returned if the resource was not found.
+ */
+ public String httpErrorMessage() {
+ return httpErrorMessage;
+ }
+
+ /**
+ * Returns an optional textual description of the operation.
+ */
+ public String description() {
+ return description;
+ }
+
+ /**
+ * Checks if this operation exists.
+ *
+ * @return {@code true} if this operation exists, {@code false} otherwise
+ * @throws ComputeException upon failure
+ */
+ public boolean exists() throws ComputeException {
+ return reload(Compute.OperationOption.fields()) != null;
+ }
+
+ /**
+ * Checks if this operation has completed its execution, either failing or succeeding. If the
+ * operation does not exist this method returns {@code false}. To correctly wait for operation's
+ * completion check that the operation exists first, using {@link #exists()}:
+ * {@code
+ * if (operation.exists()) {
+ * while(!operation.isDone()) {
+ * Thread.sleep(1000L);
+ * }
+ * }}
+ *
+ * @return {@code true} if this operation is in {@link Operation.Status#DONE} state, {@code false}
+ * if the state is not {@link Operation.Status#DONE} or the operation does not exist
+ * @throws ComputeException upon failure
+ */
+ public boolean isDone() throws ComputeException {
+ Operation operation =
+ compute.get(operationId, Compute.OperationOption.fields(Compute.OperationField.STATUS));
+ return operation != null && operation.status() == Status.DONE;
+ }
+
+ /**
+ * Fetches current operation's latest information. Returns {@code null} if the operation does not
+ * exist.
+ *
+ * @param options operation options
+ * @return an {@code Operation} object with latest information or {@code null} if not found
+ * @throws ComputeException upon failure
+ */
+ public Operation reload(Compute.OperationOption... options) throws ComputeException {
+ return compute.get(operationId, options);
+ }
+
+ /**
+ * Deletes this operation.
+ *
+ * @return {@code true} if operation was deleted, {@code false} if it was not found
+ * @throws ComputeException upon failure
+ */
+ public boolean delete() throws ComputeException {
+ return compute.delete(operationId);
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(this)
+ .add("id", id)
+ .add("operationsId", operationId)
+ .add("creationTimestamp", creationTimestamp)
+ .add("clientOperationId", clientOperationId)
+ .add("operationType", operationType)
+ .add("targetLink", targetLink)
+ .add("targetId", targetId)
+ .add("status", status)
+ .add("statusMessage", statusMessage)
+ .add("user", user)
+ .add("progress", progress)
+ .add("insertTime", insertTime)
+ .add("startTime", startTime)
+ .add("endTime", endTime)
+ .add("errors", errors)
+ .add("warnings", warnings)
+ .add("httpErrorStatusCode", httpErrorStatusCode)
+ .add("httpErrorMessage", httpErrorMessage)
+ .add("description", description)
+ .toString();
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(id);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ return obj instanceof Operation
+ && Objects.equals(toPb(), ((Operation) obj).toPb())
+ && Objects.equals(options, ((Operation) obj).options);
+ }
+
+ com.google.api.services.compute.model.Operation toPb() {
+ com.google.api.services.compute.model.Operation operationPb =
+ new com.google.api.services.compute.model.Operation();
+ if (id != null) {
+ operationPb.setId(new BigInteger(id));
+ }
+ if (creationTimestamp != null) {
+ operationPb.setCreationTimestamp(TIMESTAMP_FORMATTER.print(creationTimestamp));
+ }
+ operationPb.setName(operationId.operation());
+ operationPb.setClientOperationId(clientOperationId);
+ if (operationId instanceof RegionOperationId) {
+ operationPb.setRegion(this.operationId().regionId().selfLink());
+ }
+ if (operationId instanceof ZoneOperationId) {
+ operationPb.setZone(this.operationId().zoneId().selfLink());
+ }
+ if (operationType != null) {
+ operationPb.setOperationType(operationType);
+ }
+ operationPb.setTargetLink(targetLink);
+ if (targetId != null) {
+ operationPb.setTargetId(new BigInteger(targetId));
+ }
+ if (status != null) {
+ operationPb.setStatus(status.name());
+ }
+ operationPb.setStatusMessage(statusMessage);
+ operationPb.setUser(user);
+ operationPb.setProgress(progress);
+ if (insertTime != null) {
+ operationPb.setInsertTime(TIMESTAMP_FORMATTER.print(insertTime));
+ }
+ if (startTime != null) {
+ operationPb.setStartTime(TIMESTAMP_FORMATTER.print(startTime));
+ }
+ if (endTime != null) {
+ operationPb.setEndTime(TIMESTAMP_FORMATTER.print(endTime));
+ }
+ if (errors != null) {
+ operationPb.setError(new com.google.api.services.compute.model.Operation.Error().setErrors(
+ Lists.transform(errors, OperationError.TO_PB_FUNCTION)));
+ }
+ if (warnings != null) {
+ operationPb.setWarnings(Lists.transform(warnings, OperationWarning.TO_PB_FUNCTION));
+ }
+ operationPb.setHttpErrorStatusCode(httpErrorStatusCode);
+ operationPb.setHttpErrorMessage(httpErrorMessage);
+ operationPb.setSelfLink(operationId.selfLink());
+ operationPb.setDescription(description);
+ return operationPb;
+ }
+
+ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+ in.defaultReadObject();
+ this.compute = options.service();
+ }
+
+ static Operation fromPb(Compute compute,
+ com.google.api.services.compute.model.Operation operationPb) {
+ return new Builder(compute, operationPb).build();
+ }
+}
diff --git a/gcloud-java-compute/src/main/java/com/google/gcloud/compute/OperationId.java b/gcloud-java-compute/src/main/java/com/google/gcloud/compute/OperationId.java
new file mode 100644
index 000000000000..c7211e97ca2d
--- /dev/null
+++ b/gcloud-java-compute/src/main/java/com/google/gcloud/compute/OperationId.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2016 Google Inc. All Rights Reserved.
+ *
+ * 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.gcloud.compute;
+
+/**
+ * Interface for Google Compute Engine operation identities.
+ */
+public interface OperationId {
+
+ /**
+ * Returns the name of the project.
+ */
+ String project();
+
+ /**
+ * Returns the name of the operation resource.
+ */
+ String operation();
+
+ /**
+ * Returns a fully qualified URL to the entity.
+ */
+ String selfLink();
+}
diff --git a/gcloud-java-compute/src/main/java/com/google/gcloud/compute/RegionOperationId.java b/gcloud-java-compute/src/main/java/com/google/gcloud/compute/RegionOperationId.java
new file mode 100644
index 000000000000..acc23410d285
--- /dev/null
+++ b/gcloud-java-compute/src/main/java/com/google/gcloud/compute/RegionOperationId.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2016 Google Inc. All Rights Reserved.
+ *
+ * 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.gcloud.compute;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Identity for a Google Compute Engine region's operation.
+ */
+public final class RegionOperationId extends RegionResourceId implements OperationId {
+
+ private static final String REGEX = RegionResourceId.REGEX + "operations/([^/]+)";
+ private static final Pattern PATTERN = Pattern.compile(REGEX);
+ private static final long serialVersionUID = 5816161906501886782L;
+
+ private final String operation;
+
+ private RegionOperationId(String project, String region, String operation) {
+ super(project, region);
+ this.operation = checkNotNull(operation);
+ }
+
+ @Override
+ public String operation() {
+ return operation;
+ }
+
+ @Override
+ public String selfLink() {
+ return super.selfLink() + "/operations/" + operation;
+ }
+
+ @Override
+ MoreObjects.ToStringHelper toStringHelper() {
+ return MoreObjects.toStringHelper(this).add("operation", operation);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(baseHashCode(), operation);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ return obj instanceof RegionOperationId && baseEquals((RegionOperationId) obj);
+ }
+
+ @Override
+ RegionOperationId setProjectId(String projectId) {
+ if (project() != null) {
+ return this;
+ }
+ return RegionOperationId.of(projectId, region(), operation);
+ }
+
+ /**
+ * Returns a region operation identity given the region identity and the operation name.
+ */
+ public static RegionOperationId of(RegionId regionId, String operation) {
+ return new RegionOperationId(regionId.project(), regionId.region(), operation);
+ }
+
+ /**
+ * Returns a region operation identity given the region and operation names.
+ */
+ public static RegionOperationId of(String region, String operation) {
+ return new RegionOperationId(null, region, operation);
+ }
+
+ /**
+ * Returns a region operation identity given project, region and operation names.
+ */
+ public static RegionOperationId of(String project, String region, String operation) {
+ return new RegionOperationId(project, region, operation);
+ }
+
+ /**
+ * Returns {@code true} if the provided string matches the expected format of a region operation
+ * URL. Returns {@code false} otherwise.
+ */
+ static boolean matchesUrl(String url) {
+ return PATTERN.matcher(url).matches();
+ }
+
+ static RegionOperationId fromUrl(String url) {
+ Matcher matcher = PATTERN.matcher(url);
+ if (!matcher.matches()) {
+ throw new IllegalArgumentException(url + " is not a valid region operation URL");
+ }
+ return RegionOperationId.of(matcher.group(1), matcher.group(2), matcher.group(3));
+ }
+}
diff --git a/gcloud-java-compute/src/main/java/com/google/gcloud/compute/ZoneOperationId.java b/gcloud-java-compute/src/main/java/com/google/gcloud/compute/ZoneOperationId.java
new file mode 100644
index 000000000000..c0364b0ead3f
--- /dev/null
+++ b/gcloud-java-compute/src/main/java/com/google/gcloud/compute/ZoneOperationId.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2016 Google Inc. All Rights Reserved.
+ *
+ * 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.gcloud.compute;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Identity for a Google Compute Engine zone operation.
+ */
+public final class ZoneOperationId extends ZoneResourceId implements OperationId {
+
+ private static final String REGEX = ZoneResourceId.REGEX + "operations/([^/]+)";
+ private static final Pattern PATTERN = Pattern.compile(REGEX);
+ private static final long serialVersionUID = 4910670262094017392L;
+
+ private final String operation;
+
+ private ZoneOperationId(String project, String zone, String operation) {
+ super(project, zone);
+ this.operation = checkNotNull(operation);
+ }
+
+ @Override
+ public String operation() {
+ return operation;
+ }
+
+ @Override
+ public String selfLink() {
+ return super.selfLink() + "/operations/" + operation;
+ }
+
+ @Override
+ MoreObjects.ToStringHelper toStringHelper() {
+ return MoreObjects.toStringHelper(this).add("operation", operation);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(baseHashCode(), operation);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ return obj instanceof ZoneOperationId
+ && baseEquals((ZoneOperationId) obj)
+ && Objects.equals(operation, ((ZoneOperationId) obj).operation);
+ }
+
+ @Override
+ ZoneOperationId setProjectId(String projectId) {
+ if (project() != null) {
+ return this;
+ }
+ return ZoneOperationId.of(projectId, zone(), operation);
+ }
+
+ /**
+ * Returns a zone operation identity given the zone identity and the operation name.
+ */
+ public static ZoneOperationId of(ZoneId zoneId, String operation) {
+ return new ZoneOperationId(zoneId.project(), zoneId.zone(), operation);
+ }
+
+ /**
+ * Returns a zone operation identity given the zone and operation names.
+ */
+ public static ZoneOperationId of(String zone, String operation) {
+ return new ZoneOperationId(null, zone, operation);
+ }
+
+ /**
+ * Returns a zone operation identity given project, zone and operation names.
+ */
+ public static ZoneOperationId of(String project, String zone, String operation) {
+ return new ZoneOperationId(project, zone, operation);
+ }
+
+ /**
+ * Returns {@code true} if the provided string matches the expected format of a zone operation
+ * URL. Returns {@code false} otherwise.
+ */
+ static boolean matchesUrl(String url) {
+ return PATTERN.matcher(url).matches();
+ }
+
+ static ZoneOperationId fromUrl(String url) {
+ Matcher matcher = PATTERN.matcher(url);
+ if (!matcher.matches()) {
+ throw new IllegalArgumentException(url + " is not a valid zone operation URL");
+ }
+ return ZoneOperationId.of(matcher.group(1), matcher.group(2), matcher.group(3));
+ }
+}
diff --git a/gcloud-java-compute/src/main/java/com/google/gcloud/spi/ComputeRpc.java b/gcloud-java-compute/src/main/java/com/google/gcloud/spi/ComputeRpc.java
index 35524e0c116d..13b391adb75e 100644
--- a/gcloud-java-compute/src/main/java/com/google/gcloud/spi/ComputeRpc.java
+++ b/gcloud-java-compute/src/main/java/com/google/gcloud/spi/ComputeRpc.java
@@ -19,6 +19,7 @@
import com.google.api.services.compute.model.DiskType;
import com.google.api.services.compute.model.License;
import com.google.api.services.compute.model.MachineType;
+import com.google.api.services.compute.model.Operation;
import com.google.api.services.compute.model.Region;
import com.google.api.services.compute.model.Zone;
import com.google.gcloud.compute.ComputeException;
@@ -161,4 +162,70 @@ public Y y() {
* @throws ComputeException upon failure
*/
License getLicense(String project, String license, Map options);
+
+ /**
+ * Returns the requested global operation or {@code null} if not found.
+ *
+ * @throws ComputeException upon failure
+ */
+ Operation getGlobalOperation(String operation, Map options);
+
+ /**
+ * Lists the global operations in the current project.
+ *
+ * @throws ComputeException upon failure
+ */
+ Tuple> listGlobalOperations(Map options);
+
+ /**
+ * Deletes the requested global operation.
+ *
+ * @return {@code true} if operation was deleted, {@code false} if it was not found
+ * @throws ComputeException upon failure
+ */
+ boolean deleteGlobalOperation(String operation);
+
+ /**
+ * Returns the requested region operation or {@code null} if not found.
+ *
+ * @throws ComputeException upon failure
+ */
+ Operation getRegionOperation(String region, String operation, Map options);
+
+ /**
+ * Lists the region operations for the current project and region.
+ *
+ * @throws ComputeException upon failure
+ */
+ Tuple> listRegionOperations(String region, Map options);
+
+ /**
+ * Deletes the requested region operation.
+ *
+ * @return {@code true} if operation was deleted, {@code false} if it was not found
+ * @throws ComputeException upon failure
+ */
+ boolean deleteRegionOperation(String region, String operation);
+
+ /**
+ * Returns the requested zone operation or {@code null} if not found.
+ *
+ * @throws ComputeException upon failure
+ */
+ Operation getZoneOperation(String zone, String operation, Map options);
+
+ /**
+ * Lists the zone operations for the current project and zone.
+ *
+ * @throws ComputeException upon failure
+ */
+ Tuple> listZoneOperations(String zone, Map options);
+
+ /**
+ * Deletes the requested zone operation.
+ *
+ * @return {@code true} if operation was deleted, {@code false} if it was not found
+ * @throws ComputeException upon failure
+ */
+ boolean deleteZoneOperation(String zone, String operation);
}
diff --git a/gcloud-java-compute/src/main/java/com/google/gcloud/spi/DefaultComputeRpc.java b/gcloud-java-compute/src/main/java/com/google/gcloud/spi/DefaultComputeRpc.java
index fe714acab502..c7ff42ca0438 100644
--- a/gcloud-java-compute/src/main/java/com/google/gcloud/spi/DefaultComputeRpc.java
+++ b/gcloud-java-compute/src/main/java/com/google/gcloud/spi/DefaultComputeRpc.java
@@ -35,6 +35,8 @@
import com.google.api.services.compute.model.MachineTypeAggregatedList;
import com.google.api.services.compute.model.MachineTypeList;
import com.google.api.services.compute.model.MachineTypesScopedList;
+import com.google.api.services.compute.model.Operation;
+import com.google.api.services.compute.model.OperationList;
import com.google.api.services.compute.model.Region;
import com.google.api.services.compute.model.RegionList;
import com.google.api.services.compute.model.Zone;
@@ -261,4 +263,146 @@ private static T nullForNotFound(IOException exception) {
}
throw serviceException;
}
+
+ @Override
+ public Operation getGlobalOperation(String operation, Map options) {
+ try {
+ return compute.globalOperations()
+ .get(this.options.projectId(), operation)
+ .setFields(FIELDS.getString(options))
+ .execute();
+ } catch (IOException ex) {
+ ComputeException serviceException = translate(ex);
+ if (serviceException.code() == HTTP_NOT_FOUND) {
+ return null;
+ }
+ throw serviceException;
+ }
+ }
+
+ @Override
+ public Tuple> listGlobalOperations(Map options) {
+ try {
+ OperationList operationsList = compute.globalOperations()
+ .list(this.options.projectId())
+ .setFilter(FILTER.getString(options))
+ .setMaxResults(MAX_RESULTS.getLong(options))
+ .setPageToken(PAGE_TOKEN.getString(options))
+ .setFields(FIELDS.getString(options))
+ .execute();
+ Iterable operations = operationsList.getItems();
+ return Tuple.of(operationsList.getNextPageToken(), operations);
+ } catch (IOException ex) {
+ throw translate(ex);
+ }
+ }
+
+ @Override
+ public boolean deleteGlobalOperation(String operation) {
+ try {
+ compute.globalOperations().delete(this.options.projectId(), operation).execute();
+ return true;
+ } catch (IOException ex) {
+ ComputeException serviceException = translate(ex);
+ if (serviceException.code() == HTTP_NOT_FOUND) {
+ return false;
+ }
+ throw serviceException;
+ }
+ }
+
+ @Override
+ public Operation getRegionOperation(String region, String operation, Map options) {
+ try {
+ return compute.regionOperations()
+ .get(this.options.projectId(), region, operation)
+ .setFields(FIELDS.getString(options))
+ .execute();
+ } catch (IOException ex) {
+ ComputeException serviceException = translate(ex);
+ if (serviceException.code() == HTTP_NOT_FOUND) {
+ return null;
+ }
+ throw serviceException;
+ }
+ }
+
+ @Override
+ public Tuple> listRegionOperations(String region,
+ Map options) {
+ try {
+ OperationList operationsList = compute.regionOperations()
+ .list(this.options.projectId(), region)
+ .setFilter(FILTER.getString(options))
+ .setMaxResults(MAX_RESULTS.getLong(options))
+ .setPageToken(PAGE_TOKEN.getString(options))
+ .setFields(FIELDS.getString(options))
+ .execute();
+ Iterable operations = operationsList.getItems();
+ return Tuple.of(operationsList.getNextPageToken(), operations);
+ } catch (IOException ex) {
+ throw translate(ex);
+ }
+ }
+
+ @Override
+ public boolean deleteRegionOperation(String region, String operation) {
+ try {
+ compute.regionOperations().delete(this.options.projectId(), region, operation).execute();
+ return true;
+ } catch (IOException ex) {
+ ComputeException serviceException = translate(ex);
+ if (serviceException.code() == HTTP_NOT_FOUND) {
+ return false;
+ }
+ throw serviceException;
+ }
+ }
+
+ @Override
+ public Operation getZoneOperation(String zone, String operation, Map options) {
+ try {
+ return compute.zoneOperations()
+ .get(this.options.projectId(), zone, operation)
+ .setFields(FIELDS.getString(options))
+ .execute();
+ } catch (IOException ex) {
+ ComputeException serviceException = translate(ex);
+ if (serviceException.code() == HTTP_NOT_FOUND) {
+ return null;
+ }
+ throw serviceException;
+ }
+ }
+
+ @Override
+ public Tuple> listZoneOperations(String zone, Map options) {
+ try {
+ OperationList operationsList = compute.zoneOperations()
+ .list(this.options.projectId(), zone)
+ .setFilter(FILTER.getString(options))
+ .setMaxResults(MAX_RESULTS.getLong(options))
+ .setPageToken(PAGE_TOKEN.getString(options))
+ .setFields(FIELDS.getString(options))
+ .execute();
+ Iterable operations = operationsList.getItems();
+ return Tuple.of(operationsList.getNextPageToken(), operations);
+ } catch (IOException ex) {
+ throw translate(ex);
+ }
+ }
+
+ @Override
+ public boolean deleteZoneOperation(String zone, String operation) {
+ try {
+ compute.zoneOperations().delete(this.options.projectId(), zone, operation).execute();
+ return true;
+ } catch (IOException ex) {
+ ComputeException serviceException = translate(ex);
+ if (serviceException.code() == HTTP_NOT_FOUND) {
+ return false;
+ }
+ throw serviceException;
+ }
+ }
}
diff --git a/gcloud-java-compute/src/test/java/com/google/gcloud/compute/ComputeImplTest.java b/gcloud-java-compute/src/test/java/com/google/gcloud/compute/ComputeImplTest.java
index 5ef9b04ed446..0d8461d611a7 100644
--- a/gcloud-java-compute/src/test/java/com/google/gcloud/compute/ComputeImplTest.java
+++ b/gcloud-java-compute/src/test/java/com/google/gcloud/compute/ComputeImplTest.java
@@ -20,10 +20,12 @@
import static org.easymock.EasyMock.eq;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
+import com.google.common.base.Function;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
@@ -117,6 +119,37 @@ public class ComputeImplTest {
private static final LicenseId LICENSE_ID = LicenseId.of("project", "license");
private static final Boolean CHARGES_USE_FEE = true;
private static final License LICENSE = new License(LICENSE_ID, CHARGES_USE_FEE);
+ private static final Operation.OperationError OPERATION_ERROR1 =
+ new Operation.OperationError("code1", "location1", "message1");
+ private static final Operation.OperationError OPERATION_ERROR2 =
+ new Operation.OperationError("code2", "location2", "message2");
+ private static final Operation.OperationWarning OPERATION_WARNING1 =
+ new Operation.OperationWarning("code1", "message1", ImmutableMap.of("k1", "v1"));
+ private static final Operation.OperationWarning OPERATION_WARNING2 =
+ new Operation.OperationWarning("code2", "location2", ImmutableMap.of("k2", "v2"));
+ private static final String CLIENT_OPERATION_ID = "clientOperationId";
+ private static final String OPERATION_TYPE = "delete";
+ private static final String TARGET_LINK = "targetLink";
+ private static final String TARGET_ID = "42";
+ private static final Operation.Status STATUS = Operation.Status.DONE;
+ private static final String STATUS_MESSAGE = "statusMessage";
+ private static final String USER = "user";
+ private static final Integer PROGRESS = 100;
+ private static final Long INSERT_TIME = 1453293540000L;
+ private static final Long START_TIME = 1453293420000L;
+ private static final Long END_TIME = 1453293480000L;
+ private static final List ERRORS =
+ ImmutableList.of(OPERATION_ERROR1, OPERATION_ERROR2);
+ private static final List WARNINGS =
+ ImmutableList.of(OPERATION_WARNING1, OPERATION_WARNING2);
+ private static final Integer HTTP_ERROR_STATUS_CODE = 404;
+ private static final String HTTP_ERROR_MESSAGE = "NOT FOUND";
+ private static final GlobalOperationId GLOBAL_OPERATION_ID =
+ GlobalOperationId.of("project", "op");
+ private static final ZoneOperationId ZONE_OPERATION_ID =
+ ZoneOperationId.of("project", "zone", "op");
+ private static final RegionOperationId REGION_OPERATION_ID =
+ RegionOperationId.of("project", "region", "op");
// Empty ComputeRpc options
private static final Map EMPTY_RPC_OPTIONS = ImmutableMap.of();
@@ -216,11 +249,33 @@ public class ComputeImplTest {
private static final Compute.LicenseOption LICENSE_OPTION_FIELDS =
Compute.LicenseOption.fields(Compute.LicenseField.CHARGES_USE_FEE);
+ // Operation options
+ private static final Compute.OperationOption OPERATION_OPTION_FIELDS =
+ Compute.OperationOption.fields(Compute.OperationField.ID, Compute.OperationField.DESCRIPTION);
+
+ // Operation list options
+ private static final Compute.OperationFilter OPERATION_FILTER =
+ Compute.OperationFilter.notEquals(Compute.OperationField.PROGRESS, 0);
+ private static final Compute.OperationListOption OPERATION_LIST_PAGE_TOKEN =
+ Compute.OperationListOption.startPageToken("cursor");
+ private static final Compute.OperationListOption OPERATION_LIST_MAX_RESULTS =
+ Compute.OperationListOption.maxResults(42L);
+ private static final Compute.OperationListOption OPERATION_LIST_FILTER =
+ Compute.OperationListOption.filter(OPERATION_FILTER);
+ private static final Map OPERATION_LIST_OPTIONS = ImmutableMap.of(
+ ComputeRpc.Option.PAGE_TOKEN, "cursor",
+ ComputeRpc.Option.MAX_RESULTS, 42L,
+ ComputeRpc.Option.FILTER, "progress ne 0");
+
private ComputeOptions options;
private ComputeRpcFactory rpcFactoryMock;
private ComputeRpc computeRpcMock;
private Compute compute;
+ private Operation globalOperation;
+ private Operation zoneOperation;
+ private Operation regionOperation;
+
@Rule
public ExpectedException thrown = ExpectedException.none();
@@ -229,13 +284,77 @@ public void setUp() {
rpcFactoryMock = EasyMock.createMock(ComputeRpcFactory.class);
computeRpcMock = EasyMock.createMock(ComputeRpc.class);
EasyMock.expect(rpcFactoryMock.create(EasyMock.anyObject(ComputeOptions.class)))
- .andReturn(computeRpcMock).times(1);
+ .andReturn(computeRpcMock).times(2);
EasyMock.replay(rpcFactoryMock);
options = ComputeOptions.builder()
.projectId(PROJECT)
.serviceRpcFactory(rpcFactoryMock)
.retryParams(RetryParams.noRetries())
.build();
+ Compute otherService = options.toBuilder().build().service();
+ globalOperation = new Operation.Builder(otherService)
+ .id(ID)
+ .creationTimestamp(CREATION_TIMESTAMP)
+ .operationId(GLOBAL_OPERATION_ID)
+ .clientOperationId(CLIENT_OPERATION_ID)
+ .operationType(OPERATION_TYPE)
+ .targetLink(TARGET_LINK)
+ .targetId(TARGET_ID)
+ .status(STATUS)
+ .statusMessage(STATUS_MESSAGE)
+ .user(USER)
+ .progress(PROGRESS)
+ .insertTime(INSERT_TIME)
+ .startTime(START_TIME)
+ .endTime(END_TIME)
+ .errors(ERRORS)
+ .warnings(WARNINGS)
+ .httpErrorStatusCode(HTTP_ERROR_STATUS_CODE)
+ .httpErrorMessage(HTTP_ERROR_MESSAGE)
+ .description(DESCRIPTION)
+ .build();
+ zoneOperation = new Operation.Builder(otherService)
+ .id(ID)
+ .creationTimestamp(CREATION_TIMESTAMP)
+ .operationId(ZONE_OPERATION_ID)
+ .clientOperationId(CLIENT_OPERATION_ID)
+ .operationType(OPERATION_TYPE)
+ .targetLink(TARGET_LINK)
+ .targetId(TARGET_ID)
+ .status(STATUS)
+ .statusMessage(STATUS_MESSAGE)
+ .user(USER)
+ .progress(PROGRESS)
+ .insertTime(INSERT_TIME)
+ .startTime(START_TIME)
+ .endTime(END_TIME)
+ .errors(ERRORS)
+ .warnings(WARNINGS)
+ .httpErrorStatusCode(HTTP_ERROR_STATUS_CODE)
+ .httpErrorMessage(HTTP_ERROR_MESSAGE)
+ .description(DESCRIPTION)
+ .build();
+ regionOperation = new Operation.Builder(otherService)
+ .id(ID)
+ .creationTimestamp(CREATION_TIMESTAMP)
+ .operationId(REGION_OPERATION_ID)
+ .clientOperationId(CLIENT_OPERATION_ID)
+ .operationType(OPERATION_TYPE)
+ .targetLink(TARGET_LINK)
+ .targetId(TARGET_ID)
+ .status(STATUS)
+ .statusMessage(STATUS_MESSAGE)
+ .user(USER)
+ .progress(PROGRESS)
+ .insertTime(INSERT_TIME)
+ .startTime(START_TIME)
+ .endTime(END_TIME)
+ .errors(ERRORS)
+ .warnings(WARNINGS)
+ .httpErrorStatusCode(HTTP_ERROR_STATUS_CODE)
+ .httpErrorMessage(HTTP_ERROR_MESSAGE)
+ .description(DESCRIPTION)
+ .build();
}
@After
@@ -682,6 +801,24 @@ public void testGetLicenseFromStringWithOptions() {
assertEquals(LICENSE, license);
}
+ @Test
+ public void testGetLicenseFromIdWithOptions() {
+ Capture> capturedOptions = Capture.newInstance();
+ LicenseId licenseId = LicenseId.of("project2", "license2");
+ EasyMock.expect(computeRpcMock.getLicense(eq(licenseId.project()), eq(licenseId.license()),
+ capture(capturedOptions)))
+ .andReturn(LICENSE.toPb());
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ License license = compute.getLicense(licenseId, LICENSE_OPTION_FIELDS);
+ assertEquals(LICENSE, license);
+ String selector = (String) capturedOptions.getValue().get(LICENSE_OPTION_FIELDS.rpcOption());
+ assertTrue(selector.contains("selfLink"));
+ assertTrue(selector.contains("chargesUseFee"));
+ assertEquals(22, selector.length());
+ assertEquals(LICENSE, license);
+ }
+
@Test
public void testGetLicenseFromId() {
LicenseId licenseId = LicenseId.of("project2", "license2");
@@ -695,20 +832,355 @@ public void testGetLicenseFromId() {
}
@Test
- public void testGetLicenseFromIdWithOptions() {
+ public void testGetGlobalOperation() {
+ EasyMock.expect(
+ computeRpcMock.getGlobalOperation(GLOBAL_OPERATION_ID.operation(), EMPTY_RPC_OPTIONS))
+ .andReturn(globalOperation.toPb());
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ Operation operation = compute.get(GLOBAL_OPERATION_ID);
+ assertEquals(globalOperation, operation);
+ }
+
+ @Test
+ public void testGetGlobalOperationWithSelectedFields() {
Capture> capturedOptions = Capture.newInstance();
- LicenseId licenseId = LicenseId.of("project2", "license2");
- EasyMock.expect(computeRpcMock.getLicense(eq(licenseId.project()), eq(licenseId.license()),
- capture(capturedOptions)))
- .andReturn(LICENSE.toPb());
+ EasyMock.expect(computeRpcMock.getGlobalOperation(
+ eq(GLOBAL_OPERATION_ID.operation()), capture(capturedOptions)))
+ .andReturn(globalOperation.toPb());
EasyMock.replay(computeRpcMock);
compute = options.service();
- License license = compute.getLicense(licenseId, LICENSE_OPTION_FIELDS);
- assertEquals(LICENSE, license);
- String selector = (String) capturedOptions.getValue().get(LICENSE_OPTION_FIELDS.rpcOption());
+ Operation operation = compute.get(GLOBAL_OPERATION_ID, OPERATION_OPTION_FIELDS);
+ String selector = (String) capturedOptions.getValue().get(OPERATION_OPTION_FIELDS.rpcOption());
assertTrue(selector.contains("selfLink"));
- assertTrue(selector.contains("chargesUseFee"));
- assertEquals(22, selector.length());
- assertEquals(LICENSE, license);
+ assertTrue(selector.contains("id"));
+ assertTrue(selector.contains("description"));
+ assertEquals(23, selector.length());
+ assertEquals(globalOperation, operation);
+ }
+
+ @Test
+ public void testListGlobalOperations() {
+ String cursor = "cursor";
+ compute = options.service();
+ ImmutableList operationList = ImmutableList.of(globalOperation, globalOperation);
+ Tuple> result =
+ Tuple.of(cursor, Iterables.transform(operationList,
+ new Function() {
+ @Override
+ public com.google.api.services.compute.model.Operation apply(Operation operation) {
+ return operation.toPb();
+ }
+ }));
+ EasyMock.expect(computeRpcMock.listGlobalOperations(EMPTY_RPC_OPTIONS)).andReturn(result);
+ EasyMock.replay(computeRpcMock);
+ Page page = compute.listGlobalOperations();
+ assertEquals(cursor, page.nextPageCursor());
+ assertArrayEquals(operationList.toArray(), Iterables.toArray(page.values(), Operation.class));
+ }
+
+ @Test
+ public void testListEmptyGlobalOperations() {
+ ImmutableList operations = ImmutableList.of();
+ Tuple> result =
+ Tuple.>of(null,
+ operations);
+ EasyMock.expect(computeRpcMock.listGlobalOperations(EMPTY_RPC_OPTIONS)).andReturn(result);
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ Page page = compute.listGlobalOperations();
+ assertNull(page.nextPageCursor());
+ assertArrayEquals(operations.toArray(), Iterables.toArray(page.values(), Operation.class));
+ }
+
+ @Test
+ public void testListGlobalOperationsWithOptions() {
+ String cursor = "cursor";
+ compute = options.service();
+ ImmutableList operationList = ImmutableList.of(globalOperation, globalOperation);
+ Tuple> result =
+ Tuple.of(cursor, Iterables.transform(operationList,
+ new Function() {
+ @Override
+ public com.google.api.services.compute.model.Operation apply(Operation operation) {
+ return operation.toPb();
+ }
+ }));
+ EasyMock.expect(computeRpcMock.listGlobalOperations(OPERATION_LIST_OPTIONS)).andReturn(result);
+ EasyMock.replay(computeRpcMock);
+ Page page = compute.listGlobalOperations(OPERATION_LIST_MAX_RESULTS,
+ OPERATION_LIST_PAGE_TOKEN, OPERATION_LIST_FILTER);
+ assertEquals(cursor, page.nextPageCursor());
+ assertArrayEquals(operationList.toArray(), Iterables.toArray(page.values(), Operation.class));
+ }
+
+ @Test
+ public void testDeleteGlobalOperation_True() {
+ EasyMock.expect(computeRpcMock.deleteGlobalOperation(GLOBAL_OPERATION_ID.operation()))
+ .andReturn(true);
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ assertTrue(compute.delete(GLOBAL_OPERATION_ID));
+ }
+
+ @Test
+ public void testDeleteGlobalOperation_False() {
+ EasyMock.expect(computeRpcMock.deleteGlobalOperation(GLOBAL_OPERATION_ID.operation()))
+ .andReturn(false);
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ assertFalse(compute.delete(GLOBAL_OPERATION_ID));
+ }
+
+ @Test
+ public void testGetRegionOperation() {
+ EasyMock.expect(computeRpcMock.getRegionOperation(REGION_OPERATION_ID.region(),
+ REGION_OPERATION_ID.operation(), EMPTY_RPC_OPTIONS))
+ .andReturn(regionOperation.toPb());
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ Operation operation = compute.get(REGION_OPERATION_ID);
+ assertEquals(regionOperation, operation);
+ }
+
+ @Test
+ public void testGetRegionOperationWithSelectedFields() {
+ Capture> capturedOptions = Capture.newInstance();
+ EasyMock.expect(computeRpcMock.getRegionOperation(eq(REGION_OPERATION_ID.region()),
+ eq(REGION_OPERATION_ID.operation()), capture(capturedOptions)))
+ .andReturn(regionOperation.toPb());
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ Operation operation = compute.get(REGION_OPERATION_ID, OPERATION_OPTION_FIELDS);
+ String selector = (String) capturedOptions.getValue().get(OPERATION_OPTION_FIELDS.rpcOption());
+ assertTrue(selector.contains("selfLink"));
+ assertTrue(selector.contains("id"));
+ assertTrue(selector.contains("description"));
+ assertEquals(23, selector.length());
+ assertEquals(regionOperation, operation);
+ }
+
+ @Test
+ public void testListRegionOperations() {
+ String cursor = "cursor";
+ compute = options.service();
+ ImmutableList operationList = ImmutableList.of(regionOperation, regionOperation);
+ Tuple> result =
+ Tuple.of(cursor, Iterables.transform(operationList,
+ new Function() {
+ @Override
+ public com.google.api.services.compute.model.Operation apply(Operation operation) {
+ return operation.toPb();
+ }
+ }));
+ EasyMock.expect(
+ computeRpcMock.listRegionOperations(REGION_OPERATION_ID.region(), EMPTY_RPC_OPTIONS))
+ .andReturn(result);
+ EasyMock.replay(computeRpcMock);
+ Page page = compute.listRegionOperations(REGION_OPERATION_ID.region());
+ assertEquals(cursor, page.nextPageCursor());
+ assertArrayEquals(operationList.toArray(), Iterables.toArray(page.values(), Operation.class));
+ }
+
+ @Test
+ public void testListEmptyRegionOperations() {
+ ImmutableList operations = ImmutableList.of();
+ Tuple> result =
+ Tuple.>of(null,
+ operations);
+ EasyMock.expect(
+ computeRpcMock.listRegionOperations(REGION_OPERATION_ID.region(), EMPTY_RPC_OPTIONS))
+ .andReturn(result);
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ Page page = compute.listRegionOperations(REGION_OPERATION_ID.region());
+ assertNull(page.nextPageCursor());
+ assertArrayEquals(operations.toArray(), Iterables.toArray(page.values(), Operation.class));
+ }
+
+ @Test
+ public void testListRegionOperationsWithOptions() {
+ String cursor = "cursor";
+ compute = options.service();
+ ImmutableList operationList = ImmutableList.of(regionOperation, regionOperation);
+ Tuple> result =
+ Tuple.of(cursor, Iterables.transform(operationList,
+ new Function() {
+ @Override
+ public com.google.api.services.compute.model.Operation apply(Operation operation) {
+ return operation.toPb();
+ }
+ }));
+ EasyMock.expect(
+ computeRpcMock.listRegionOperations(REGION_OPERATION_ID.region(), OPERATION_LIST_OPTIONS))
+ .andReturn(result);
+ EasyMock.replay(computeRpcMock);
+ Page page = compute.listRegionOperations(REGION_OPERATION_ID.region(),
+ OPERATION_LIST_MAX_RESULTS, OPERATION_LIST_PAGE_TOKEN, OPERATION_LIST_FILTER);
+ assertEquals(cursor, page.nextPageCursor());
+ assertArrayEquals(operationList.toArray(), Iterables.toArray(page.values(), Operation.class));
+ }
+
+ @Test
+ public void testDeleteRegionOperation_True() {
+ EasyMock.expect(computeRpcMock.deleteRegionOperation(REGION_OPERATION_ID.region(),
+ REGION_OPERATION_ID.operation())).andReturn(true);
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ assertTrue(compute.delete(REGION_OPERATION_ID));
+ }
+
+ @Test
+ public void testDeleteRegionOperation_False() {
+ EasyMock.expect(computeRpcMock.deleteRegionOperation(REGION_OPERATION_ID.region(),
+ REGION_OPERATION_ID.operation())).andReturn(false);
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ assertFalse(compute.delete(REGION_OPERATION_ID));
+ }
+
+ @Test
+ public void testGetZoneOperation() {
+ EasyMock.expect(computeRpcMock.getZoneOperation(ZONE_OPERATION_ID.zone(),
+ ZONE_OPERATION_ID.operation(), EMPTY_RPC_OPTIONS))
+ .andReturn(zoneOperation.toPb());
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ Operation operation = compute.get(ZONE_OPERATION_ID);
+ assertEquals(zoneOperation, operation);
+ }
+
+ @Test
+ public void testGetZoneOperationWithSelectedFields() {
+ Capture> capturedOptions = Capture.newInstance();
+ EasyMock.expect(computeRpcMock.getZoneOperation(eq(ZONE_OPERATION_ID.zone()),
+ eq(ZONE_OPERATION_ID.operation()), capture(capturedOptions)))
+ .andReturn(zoneOperation.toPb());
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ Operation operation = compute.get(ZONE_OPERATION_ID, OPERATION_OPTION_FIELDS);
+ String selector = (String) capturedOptions.getValue().get(OPERATION_OPTION_FIELDS.rpcOption());
+ assertTrue(selector.contains("selfLink"));
+ assertTrue(selector.contains("id"));
+ assertTrue(selector.contains("description"));
+ assertEquals(23, selector.length());
+ assertEquals(zoneOperation, operation);
+ }
+
+ @Test
+ public void testListZoneOperations() {
+ String cursor = "cursor";
+ compute = options.service();
+ ImmutableList operationList = ImmutableList.of(zoneOperation, zoneOperation);
+ Tuple> result =
+ Tuple.of(cursor, Iterables.transform(operationList,
+ new Function() {
+ @Override
+ public com.google.api.services.compute.model.Operation apply(Operation operation) {
+ return operation.toPb();
+ }
+ }));
+ EasyMock.expect(
+ computeRpcMock.listZoneOperations(ZONE_OPERATION_ID.zone(), EMPTY_RPC_OPTIONS))
+ .andReturn(result);
+ EasyMock.replay(computeRpcMock);
+ Page page = compute.listZoneOperations(ZONE_OPERATION_ID.zone());
+ assertEquals(cursor, page.nextPageCursor());
+ assertArrayEquals(operationList.toArray(), Iterables.toArray(page.values(), Operation.class));
+ }
+
+ @Test
+ public void testListEmptyZoneOperations() {
+ ImmutableList operations = ImmutableList.of();
+ Tuple> result =
+ Tuple.>of(null,
+ operations);
+ EasyMock.expect(
+ computeRpcMock.listZoneOperations(ZONE_OPERATION_ID.zone(), EMPTY_RPC_OPTIONS))
+ .andReturn(result);
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ Page page = compute.listZoneOperations(ZONE_OPERATION_ID.zone());
+ assertNull(page.nextPageCursor());
+ assertArrayEquals(operations.toArray(), Iterables.toArray(page.values(), Operation.class));
+ }
+
+ @Test
+ public void testListZoneOperationsWithOptions() {
+ String cursor = "cursor";
+ compute = options.service();
+ ImmutableList operationList = ImmutableList.of(zoneOperation, zoneOperation);
+ Tuple> result =
+ Tuple.of(cursor, Iterables.transform(operationList,
+ new Function() {
+ @Override
+ public com.google.api.services.compute.model.Operation apply(Operation operation) {
+ return operation.toPb();
+ }
+ }));
+ EasyMock.expect(
+ computeRpcMock.listZoneOperations(ZONE_OPERATION_ID.zone(), OPERATION_LIST_OPTIONS))
+ .andReturn(result);
+ EasyMock.replay(computeRpcMock);
+ Page page = compute.listZoneOperations(ZONE_OPERATION_ID.zone(),
+ OPERATION_LIST_MAX_RESULTS, OPERATION_LIST_PAGE_TOKEN, OPERATION_LIST_FILTER);
+ assertEquals(cursor, page.nextPageCursor());
+ assertArrayEquals(operationList.toArray(), Iterables.toArray(page.values(), Operation.class));
+ }
+
+ @Test
+ public void testDeleteZoneOperation_True() {
+ EasyMock.expect(computeRpcMock.deleteZoneOperation(ZONE_OPERATION_ID.zone(),
+ ZONE_OPERATION_ID.operation())).andReturn(true);
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ assertTrue(compute.delete(ZONE_OPERATION_ID));
+ }
+
+ @Test
+ public void testDeleteZoneOperation_False() {
+ EasyMock.expect(computeRpcMock.deleteZoneOperation(ZONE_OPERATION_ID.zone(),
+ ZONE_OPERATION_ID.operation())).andReturn(false);
+ EasyMock.replay(computeRpcMock);
+ compute = options.service();
+ assertFalse(compute.delete(ZONE_OPERATION_ID));
+ }
+
+ @Test
+ public void testRetryableException() {
+ EasyMock.expect(
+ computeRpcMock.getDiskType(DISK_TYPE_ID.zone(), DISK_TYPE_ID.diskType(), EMPTY_RPC_OPTIONS))
+ .andThrow(new ComputeException(500, "InternalError"))
+ .andReturn(DISK_TYPE.toPb());
+ EasyMock.replay(computeRpcMock);
+ compute = options.toBuilder().retryParams(RetryParams.defaultInstance()).build().service();
+ DiskType diskType = compute.getDiskType(DISK_TYPE_ID);
+ assertEquals(DISK_TYPE, diskType);
+ }
+
+ @Test
+ public void testNonRetryableException() {
+ String exceptionMessage = "Not Implemented";
+ EasyMock.expect(
+ computeRpcMock.getDiskType(DISK_TYPE_ID.zone(), DISK_TYPE_ID.diskType(), EMPTY_RPC_OPTIONS))
+ .andThrow(new ComputeException(501, exceptionMessage));
+ EasyMock.replay(computeRpcMock);
+ compute = options.toBuilder().retryParams(RetryParams.defaultInstance()).build().service();
+ thrown.expect(ComputeException.class);
+ thrown.expectMessage(exceptionMessage);
+ compute.getDiskType(DISK_TYPE_ID);
+ }
+
+ @Test
+ public void testRuntimeException() {
+ String exceptionMessage = "Artificial runtime exception";
+ EasyMock.expect(
+ computeRpcMock.getDiskType(DISK_TYPE_ID.zone(), DISK_TYPE_ID.diskType(), EMPTY_RPC_OPTIONS))
+ .andThrow(new RuntimeException(exceptionMessage));
+ EasyMock.replay(computeRpcMock);
+ compute = options.toBuilder().retryParams(RetryParams.defaultInstance()).build().service();
+ thrown.expect(ComputeException.class);
+ thrown.expectMessage(exceptionMessage);
+ compute.getDiskType(DISK_TYPE_ID);
}
}
diff --git a/gcloud-java-compute/src/test/java/com/google/gcloud/compute/OperationIdTest.java b/gcloud-java-compute/src/test/java/com/google/gcloud/compute/OperationIdTest.java
new file mode 100644
index 000000000000..98430f0d1ad5
--- /dev/null
+++ b/gcloud-java-compute/src/test/java/com/google/gcloud/compute/OperationIdTest.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2016 Google Inc. All Rights Reserved.
+ *
+ * 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.gcloud.compute;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+public class OperationIdTest {
+
+ private static final String PROJECT = "project";
+ private static final String ZONE = "zone";
+ private static final String REGION = "region";
+ private static final String NAME = "op";
+ private static final String GLOBAL_URL =
+ "https://www.googleapis.com/compute/v1/projects/project/global/operations/op";
+ private static final String ZONE_URL =
+ "https://www.googleapis.com/compute/v1/projects/project/zones/zone/operations/op";
+ private static final String REGION_URL =
+ "https://www.googleapis.com/compute/v1/projects/project/regions/region/operations/op";
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @Test
+ public void testOf() {
+ GlobalOperationId operationId = GlobalOperationId.of(PROJECT, NAME);
+ assertEquals(PROJECT, operationId.project());
+ assertEquals(NAME, operationId.operation());
+ assertEquals(GLOBAL_URL, operationId.selfLink());
+ operationId = GlobalOperationId.of(NAME);
+ assertNull(operationId.project());
+ assertEquals(NAME, operationId.operation());
+ ZoneOperationId zoneOperationId = ZoneOperationId.of(PROJECT, ZONE, NAME);
+ assertEquals(PROJECT, zoneOperationId.project());
+ assertEquals(ZONE, zoneOperationId.zone());
+ assertEquals(NAME, zoneOperationId.operation());
+ assertEquals(ZONE_URL, zoneOperationId.selfLink());
+ zoneOperationId = ZoneOperationId.of(ZONE, NAME);
+ assertNull(zoneOperationId.project());
+ assertEquals(ZONE, zoneOperationId.zone());
+ assertEquals(NAME, zoneOperationId.operation());
+ RegionOperationId regionOperationId = RegionOperationId.of(PROJECT, REGION, NAME);
+ assertEquals(PROJECT, regionOperationId.project());
+ assertEquals(REGION, regionOperationId.region());
+ assertEquals(NAME, regionOperationId.operation());
+ assertEquals(REGION_URL, regionOperationId.selfLink());
+ regionOperationId = RegionOperationId.of(REGION, NAME);
+ assertNull(regionOperationId.project());
+ assertEquals(REGION, regionOperationId.region());
+ assertEquals(NAME, regionOperationId.operation());
+ }
+
+ @Test
+ public void testToAndFromUrl() {
+ GlobalOperationId operationId = GlobalOperationId.of(PROJECT, NAME);
+ compareOperationId(operationId, GlobalOperationId.fromUrl(operationId.selfLink()));
+ thrown.expect(IllegalArgumentException.class);
+ thrown.expectMessage("notMatchingUrl is not a valid global operation URL");
+ GlobalOperationId.fromUrl("notMatchingUrl");
+ ZoneOperationId zoneOperationId = ZoneOperationId.of(PROJECT, ZONE, NAME);
+ compareZoneOperationId(zoneOperationId, ZoneOperationId.fromUrl(zoneOperationId.selfLink()));
+ thrown.expect(IllegalArgumentException.class);
+ thrown.expectMessage("notMatchingUrl is not a valid zone operation URL");
+ ZoneOperationId.fromUrl("notMatchingUrl");
+ RegionOperationId regionOperationId = RegionOperationId.of(PROJECT, REGION, NAME);
+ compareRegionOperationId(regionOperationId,
+ RegionOperationId.fromUrl(regionOperationId.selfLink()));
+ thrown.expect(IllegalArgumentException.class);
+ thrown.expectMessage("notMatchingUrl is not a valid region operation URL");
+ RegionOperationId.fromUrl("notMatchingUrl");
+ }
+
+ @Test
+ public void testSetProjectId() {
+ GlobalOperationId operationId = GlobalOperationId.of(PROJECT, NAME);
+ assertSame(operationId, operationId.setProjectId(PROJECT));
+ compareOperationId(operationId, GlobalOperationId.of(NAME).setProjectId(PROJECT));
+ ZoneOperationId zoneOperationId = ZoneOperationId.of(PROJECT, ZONE, NAME);
+ assertSame(zoneOperationId, zoneOperationId.setProjectId(PROJECT));
+ compareZoneOperationId(zoneOperationId, ZoneOperationId.of(ZONE, NAME).setProjectId(PROJECT));
+ RegionOperationId regionOperationId = RegionOperationId.of(PROJECT, REGION, NAME);
+ assertSame(regionOperationId, regionOperationId.setProjectId(PROJECT));
+ compareRegionOperationId(regionOperationId,
+ RegionOperationId.of(REGION, NAME).setProjectId(PROJECT));
+ }
+
+ @Test
+ public void testMatchesUrl() {
+ assertTrue(GlobalOperationId.matchesUrl(GlobalOperationId.of(PROJECT, NAME).selfLink()));
+ assertFalse(GlobalOperationId.matchesUrl("notMatchingUrl"));
+ assertTrue(RegionOperationId.matchesUrl(RegionOperationId.of(PROJECT, REGION, NAME).selfLink()));
+ assertFalse(RegionOperationId.matchesUrl("notMatchingUrl"));
+ assertTrue(ZoneOperationId.matchesUrl(ZoneOperationId.of(PROJECT, REGION, NAME).selfLink()));
+ assertFalse(ZoneOperationId.matchesUrl("notMatchingUrl"));
+ }
+
+ private void compareOperationId(GlobalOperationId expected, GlobalOperationId value) {
+ assertEquals(expected, value);
+ assertEquals(expected.project(), expected.project());
+ assertEquals(expected.operation(), expected.operation());
+ assertEquals(expected.selfLink(), expected.selfLink());
+ assertEquals(expected.hashCode(), expected.hashCode());
+ }
+
+ private void compareZoneOperationId(ZoneOperationId expected, ZoneOperationId value) {
+ assertEquals(expected, value);
+ assertEquals(expected.project(), expected.project());
+ assertEquals(expected.zone(), expected.zone());
+ assertEquals(expected.operation(), expected.operation());
+ assertEquals(expected.selfLink(), expected.selfLink());
+ assertEquals(expected.hashCode(), expected.hashCode());
+ }
+
+ private void compareRegionOperationId(RegionOperationId expected, RegionOperationId value) {
+ assertEquals(expected, value);
+ assertEquals(expected.project(), expected.project());
+ assertEquals(expected.region(), expected.region());
+ assertEquals(expected.operation(), expected.operation());
+ assertEquals(expected.selfLink(), expected.selfLink());
+ assertEquals(expected.hashCode(), expected.hashCode());
+ }
+}
diff --git a/gcloud-java-compute/src/test/java/com/google/gcloud/compute/OperationTest.java b/gcloud-java-compute/src/test/java/com/google/gcloud/compute/OperationTest.java
new file mode 100644
index 000000000000..05daaacda636
--- /dev/null
+++ b/gcloud-java-compute/src/test/java/com/google/gcloud/compute/OperationTest.java
@@ -0,0 +1,489 @@
+/*
+ * Copyright 2016 Google Inc. All Rights Reserved.
+ *
+ * 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.gcloud.compute;
+
+import static org.easymock.EasyMock.createMock;
+import static org.easymock.EasyMock.createStrictMock;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.replay;
+import static org.easymock.EasyMock.verify;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.gcloud.compute.Operation.OperationError;
+import com.google.gcloud.compute.Operation.Status;
+import com.google.gcloud.compute.Operation.OperationWarning;
+
+import org.junit.After;
+import org.junit.Test;
+
+import java.math.BigInteger;
+import java.util.List;
+
+public class OperationTest {
+
+ private static final OperationError OPERATION_ERROR1 =
+ new OperationError("code1", "location1", "message1");
+ private static final OperationError OPERATION_ERROR2 =
+ new OperationError("code2", "location2", "message2");
+ private static final OperationWarning OPERATION_WARNING1 =
+ new OperationWarning("code1", "message1", ImmutableMap.of("k1", "v1"));
+ private static final OperationWarning OPERATION_WARNING2 =
+ new OperationWarning("code2", "location2", ImmutableMap.of("k2", "v2"));
+ private static final String ID = "1";
+ private static final Long CREATION_TIMESTAMP = 1453293540000L;
+ private static final String CLIENT_OPERATION_ID = "clientOperationId";
+ private static final String OPERATION_TYPE = "delete";
+ private static final String TARGET_LINK = "targetLink";
+ private static final String TARGET_ID = "42";
+ private static final Status STATUS = Status.DONE;
+ private static final String STATUS_MESSAGE = "statusMessage";
+ private static final String USER = "user";
+ private static final Integer PROGRESS = 100;
+ private static final Long INSERT_TIME = 1453293540000L;
+ private static final Long START_TIME = 1453293420000L;
+ private static final Long END_TIME = 1453293480000L;
+ private static final List ERRORS =
+ ImmutableList.of(OPERATION_ERROR1, OPERATION_ERROR2);
+ private static final List WARNINGS =
+ ImmutableList.of(OPERATION_WARNING1, OPERATION_WARNING2);
+ private static final Integer HTTP_ERROR_STATUS_CODE = 404;
+ private static final String HTTP_ERROR_MESSAGE = "NOT FOUND";
+ private static final String DESCRIPTION = "description";
+ private static final GlobalOperationId GLOBAL_OPERATION_ID =
+ GlobalOperationId.of("project", "op");
+ private static final ZoneOperationId ZONE_OPERATION_ID =
+ ZoneOperationId.of("project", "zone", "op");
+ private static final RegionOperationId REGION_OPERATION_ID =
+ RegionOperationId.of("project", "region", "op");
+
+ private Compute serviceMockReturnsOptions = createStrictMock(Compute.class);
+ private ComputeOptions mockOptions = createMock(ComputeOptions.class);
+ private Compute compute;
+ private Operation globalOperation;
+ private Operation regionOperation;
+ private Operation zoneOperation;
+ private Operation operation;
+
+ private void initializeExpectedOperation(int optionsCalls) {
+ expect(serviceMockReturnsOptions.options()).andReturn(mockOptions).times(optionsCalls);
+ replay(serviceMockReturnsOptions);
+ globalOperation = new Operation.Builder(serviceMockReturnsOptions)
+ .id(ID)
+ .creationTimestamp(CREATION_TIMESTAMP)
+ .operationId(GLOBAL_OPERATION_ID)
+ .clientOperationId(CLIENT_OPERATION_ID)
+ .operationType(OPERATION_TYPE)
+ .targetLink(TARGET_LINK)
+ .targetId(TARGET_ID)
+ .status(STATUS)
+ .statusMessage(STATUS_MESSAGE)
+ .user(USER)
+ .progress(PROGRESS)
+ .insertTime(INSERT_TIME)
+ .startTime(START_TIME)
+ .endTime(END_TIME)
+ .errors(ERRORS)
+ .warnings(WARNINGS)
+ .httpErrorStatusCode(HTTP_ERROR_STATUS_CODE)
+ .httpErrorMessage(HTTP_ERROR_MESSAGE)
+ .description(DESCRIPTION)
+ .build();
+ zoneOperation = new Operation.Builder(serviceMockReturnsOptions)
+ .id(ID)
+ .creationTimestamp(CREATION_TIMESTAMP)
+ .operationId(ZONE_OPERATION_ID)
+ .clientOperationId(CLIENT_OPERATION_ID)
+ .operationType(OPERATION_TYPE)
+ .targetLink(TARGET_LINK)
+ .targetId(TARGET_ID)
+ .status(STATUS)
+ .statusMessage(STATUS_MESSAGE)
+ .user(USER)
+ .progress(PROGRESS)
+ .insertTime(INSERT_TIME)
+ .startTime(START_TIME)
+ .endTime(END_TIME)
+ .errors(ERRORS)
+ .warnings(WARNINGS)
+ .httpErrorStatusCode(HTTP_ERROR_STATUS_CODE)
+ .httpErrorMessage(HTTP_ERROR_MESSAGE)
+ .description(DESCRIPTION)
+ .build();
+ regionOperation = new Operation.Builder(serviceMockReturnsOptions)
+ .id(ID)
+ .creationTimestamp(CREATION_TIMESTAMP)
+ .operationId(REGION_OPERATION_ID)
+ .clientOperationId(CLIENT_OPERATION_ID)
+ .operationType(OPERATION_TYPE)
+ .targetLink(TARGET_LINK)
+ .targetId(TARGET_ID)
+ .status(STATUS)
+ .statusMessage(STATUS_MESSAGE)
+ .user(USER)
+ .progress(PROGRESS)
+ .insertTime(INSERT_TIME)
+ .startTime(START_TIME)
+ .endTime(END_TIME)
+ .errors(ERRORS)
+ .warnings(WARNINGS)
+ .httpErrorStatusCode(HTTP_ERROR_STATUS_CODE)
+ .httpErrorMessage(HTTP_ERROR_MESSAGE)
+ .description(DESCRIPTION)
+ .build();
+ compute = createStrictMock(Compute.class);
+ }
+
+ private void initializeOperation() {
+ operation = new Operation.Builder(compute)
+ .id(ID)
+ .operationId(GLOBAL_OPERATION_ID)
+ .creationTimestamp(CREATION_TIMESTAMP)
+ .clientOperationId(CLIENT_OPERATION_ID)
+ .operationType(OPERATION_TYPE)
+ .targetLink(TARGET_LINK)
+ .targetId(TARGET_ID)
+ .status(STATUS)
+ .statusMessage(STATUS_MESSAGE)
+ .user(USER)
+ .progress(PROGRESS)
+ .insertTime(INSERT_TIME)
+ .startTime(START_TIME)
+ .endTime(END_TIME)
+ .errors(ERRORS)
+ .warnings(WARNINGS)
+ .httpErrorStatusCode(HTTP_ERROR_STATUS_CODE)
+ .httpErrorMessage(HTTP_ERROR_MESSAGE)
+ .description(DESCRIPTION)
+ .build();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ verify(serviceMockReturnsOptions);
+ }
+
+ @Test
+ public void testBuilder() {
+ initializeExpectedOperation(6);
+ assertEquals(CREATION_TIMESTAMP, globalOperation.creationTimestamp());
+ assertEquals(ID, globalOperation.id());
+ assertEquals(GLOBAL_OPERATION_ID, globalOperation.operationId());
+ assertEquals(CLIENT_OPERATION_ID, globalOperation.clientOperationId());
+ assertEquals(OPERATION_TYPE, globalOperation.operationType());
+ assertEquals(TARGET_LINK, globalOperation.targetLink());
+ assertEquals(TARGET_ID, globalOperation.targetId());
+ assertEquals(STATUS, globalOperation.status());
+ assertEquals(STATUS_MESSAGE, globalOperation.statusMessage());
+ assertEquals(USER, globalOperation.user());
+ assertEquals(PROGRESS, globalOperation.progress());
+ assertEquals(INSERT_TIME, globalOperation.insertTime());
+ assertEquals(START_TIME, globalOperation.startTime());
+ assertEquals(END_TIME, globalOperation.endTime());
+ assertEquals(ERRORS, globalOperation.errors());
+ assertEquals(WARNINGS, globalOperation.warnings());
+ assertEquals(HTTP_ERROR_STATUS_CODE, globalOperation.httpErrorStatusCode());
+ assertEquals(HTTP_ERROR_MESSAGE, globalOperation.httpErrorMessage());
+ assertEquals(DESCRIPTION, globalOperation.description());
+ assertSame(serviceMockReturnsOptions, globalOperation.compute());
+ assertEquals(ID, regionOperation.id());
+ assertEquals(CREATION_TIMESTAMP, regionOperation.creationTimestamp());
+ assertEquals(REGION_OPERATION_ID, regionOperation.operationId());
+ assertEquals(CLIENT_OPERATION_ID, regionOperation.clientOperationId());
+ assertEquals(OPERATION_TYPE, regionOperation.operationType());
+ assertEquals(TARGET_LINK, regionOperation.targetLink());
+ assertEquals(TARGET_ID, regionOperation.targetId());
+ assertEquals(STATUS, regionOperation.status());
+ assertEquals(STATUS_MESSAGE, regionOperation.statusMessage());
+ assertEquals(USER, regionOperation.user());
+ assertEquals(PROGRESS, regionOperation.progress());
+ assertEquals(INSERT_TIME, regionOperation.insertTime());
+ assertEquals(START_TIME, regionOperation.startTime());
+ assertEquals(END_TIME, regionOperation.endTime());
+ assertEquals(ERRORS, regionOperation.errors());
+ assertEquals(WARNINGS, regionOperation.warnings());
+ assertEquals(HTTP_ERROR_STATUS_CODE, regionOperation.httpErrorStatusCode());
+ assertEquals(HTTP_ERROR_MESSAGE, regionOperation.httpErrorMessage());
+ assertEquals(DESCRIPTION, regionOperation.description());
+ assertSame(serviceMockReturnsOptions, regionOperation.compute());
+ assertEquals(ID, zoneOperation.id());
+ assertEquals(CREATION_TIMESTAMP, zoneOperation.creationTimestamp());
+ assertEquals(ZONE_OPERATION_ID, zoneOperation.operationId());
+ assertEquals(CLIENT_OPERATION_ID, zoneOperation.clientOperationId());
+ assertEquals(OPERATION_TYPE, zoneOperation.operationType());
+ assertEquals(TARGET_LINK, zoneOperation.targetLink());
+ assertEquals(TARGET_ID, zoneOperation.targetId());
+ assertEquals(STATUS, zoneOperation.status());
+ assertEquals(STATUS_MESSAGE, zoneOperation.statusMessage());
+ assertEquals(USER, zoneOperation.user());
+ assertEquals(PROGRESS, zoneOperation.progress());
+ assertEquals(INSERT_TIME, zoneOperation.insertTime());
+ assertEquals(START_TIME, zoneOperation.startTime());
+ assertEquals(END_TIME, zoneOperation.endTime());
+ assertEquals(ERRORS, zoneOperation.errors());
+ assertEquals(WARNINGS, zoneOperation.warnings());
+ assertEquals(HTTP_ERROR_STATUS_CODE, zoneOperation.httpErrorStatusCode());
+ assertEquals(HTTP_ERROR_MESSAGE, zoneOperation.httpErrorMessage());
+ assertEquals(DESCRIPTION, zoneOperation.description());
+ assertSame(serviceMockReturnsOptions, zoneOperation.compute());
+ Operation operation = new Operation.Builder(serviceMockReturnsOptions)
+ .operationId(GLOBAL_OPERATION_ID)
+ .build();
+ assertEquals(GLOBAL_OPERATION_ID, operation.operationId());
+ assertSame(serviceMockReturnsOptions, operation.compute());
+ assertNull(operation.creationTimestamp());
+ assertNull(operation.id());
+ assertNull(operation.clientOperationId());
+ assertNull(operation.operationType());
+ assertNull(operation.targetLink());
+ assertNull(operation.targetId());
+ assertNull(operation.status());
+ assertNull(operation.statusMessage());
+ assertNull(operation.user());
+ assertNull(operation.progress());
+ assertNull(operation.insertTime());
+ assertNull(operation.startTime());
+ assertNull(operation.endTime());
+ assertNull(operation.errors());
+ assertNull(operation.warnings());
+ assertNull(operation.httpErrorStatusCode());
+ assertNull(operation.httpErrorMessage());
+ assertNull(operation.description());
+ operation = new Operation.Builder(serviceMockReturnsOptions)
+ .operationId(ZONE_OPERATION_ID)
+ .build();
+ assertSame(serviceMockReturnsOptions, operation.compute());
+ assertEquals(ZONE_OPERATION_ID, operation.operationId());
+ assertNull(operation.creationTimestamp());
+ assertNull(operation.id());
+ assertNull(operation.clientOperationId());
+ assertNull(operation.operationType());
+ assertNull(operation.targetLink());
+ assertNull(operation.targetId());
+ assertNull(operation.status());
+ assertNull(operation.statusMessage());
+ assertNull(operation.user());
+ assertNull(operation.progress());
+ assertNull(operation.insertTime());
+ assertNull(operation.startTime());
+ assertNull(operation.endTime());
+ assertNull(operation.errors());
+ assertNull(operation.warnings());
+ assertNull(operation.httpErrorStatusCode());
+ assertNull(operation.httpErrorMessage());
+ assertNull(operation.description());
+ operation = new Operation.Builder(serviceMockReturnsOptions)
+ .operationId(REGION_OPERATION_ID)
+ .build();
+ assertSame(serviceMockReturnsOptions, operation.compute());
+ assertEquals(REGION_OPERATION_ID, operation.operationId());
+ assertNull(operation.creationTimestamp());
+ assertNull(operation.id());
+ assertNull(operation.clientOperationId());
+ assertNull(operation.operationType());
+ assertNull(operation.targetLink());
+ assertNull(operation.targetId());
+ assertNull(operation.status());
+ assertNull(operation.statusMessage());
+ assertNull(operation.user());
+ assertNull(operation.progress());
+ assertNull(operation.insertTime());
+ assertNull(operation.startTime());
+ assertNull(operation.endTime());
+ assertNull(operation.errors());
+ assertNull(operation.warnings());
+ assertNull(operation.httpErrorStatusCode());
+ assertNull(operation.httpErrorMessage());
+ assertNull(operation.description());
+ }
+
+ @Test
+ public void testToAndFromPb() {
+ initializeExpectedOperation(24);
+ compareOperation(globalOperation,
+ Operation.fromPb(serviceMockReturnsOptions, globalOperation.toPb()));
+ assertNotNull(regionOperation.toPb().getRegion());
+ compareOperation(regionOperation,
+ Operation.fromPb(serviceMockReturnsOptions, regionOperation.toPb()));
+ assertNotNull(zoneOperation.toPb().getZone());
+ compareOperation(zoneOperation,
+ Operation.fromPb(serviceMockReturnsOptions, zoneOperation.toPb()));
+ Operation operation = new Operation.Builder(serviceMockReturnsOptions)
+ .operationId(GLOBAL_OPERATION_ID)
+ .build();
+ compareOperation(operation, Operation.fromPb(serviceMockReturnsOptions, operation.toPb()));
+ operation = new Operation.Builder(serviceMockReturnsOptions)
+ .operationId(ZONE_OPERATION_ID)
+ .build();
+ compareOperation(operation, Operation.fromPb(serviceMockReturnsOptions, operation.toPb()));
+ operation = new Operation.Builder(serviceMockReturnsOptions)
+ .operationId(REGION_OPERATION_ID)
+ .build();
+ compareOperation(operation, Operation.fromPb(serviceMockReturnsOptions, operation.toPb()));
+ }
+
+ @Test
+ public void testDeleteTrue() {
+ initializeExpectedOperation(3);
+ expect(compute.options()).andReturn(mockOptions);
+ expect(compute.delete(GLOBAL_OPERATION_ID)).andReturn(true);
+ replay(compute);
+ initializeOperation();
+ assertTrue(operation.delete());
+ verify(compute);
+ }
+
+ @Test
+ public void testDeleteFalse() {
+ initializeExpectedOperation(3);
+ expect(compute.options()).andReturn(mockOptions);
+ expect(compute.delete(GLOBAL_OPERATION_ID)).andReturn(false);
+ replay(compute);
+ initializeOperation();
+ assertFalse(operation.delete());
+ verify(compute);
+ }
+
+ @Test
+ public void testExists_True() throws Exception {
+ initializeExpectedOperation(3);
+ Compute.OperationOption[] expectedOptions = {Compute.OperationOption.fields()};
+ expect(compute.options()).andReturn(mockOptions);
+ expect(compute.get(GLOBAL_OPERATION_ID, expectedOptions)).andReturn(globalOperation);
+ replay(compute);
+ initializeOperation();
+ assertTrue(operation.exists());
+ verify(compute);
+ }
+
+ @Test
+ public void testExists_False() throws Exception {
+ initializeExpectedOperation(3);
+ Compute.OperationOption[] expectedOptions = {Compute.OperationOption.fields()};
+ expect(compute.options()).andReturn(mockOptions);
+ expect(compute.get(GLOBAL_OPERATION_ID, expectedOptions)).andReturn(null);
+ replay(compute);
+ initializeOperation();
+ assertFalse(operation.exists());
+ verify(compute);
+ }
+
+ @Test
+ public void testIsDone_True() throws Exception {
+ initializeExpectedOperation(3);
+ Compute.OperationOption[] expectedOptions =
+ {Compute.OperationOption.fields(Compute.OperationField.STATUS)};
+ expect(compute.options()).andReturn(mockOptions);
+ expect(compute.get(GLOBAL_OPERATION_ID, expectedOptions)).andReturn(globalOperation);
+ replay(compute);
+ initializeOperation();
+ assertTrue(operation.isDone());
+ verify(compute);
+ }
+
+ @Test
+ public void testIsDone_False() throws Exception {
+ initializeExpectedOperation(4);
+ Compute.OperationOption[] expectedOptions =
+ {Compute.OperationOption.fields(Compute.OperationField.STATUS)};
+ expect(compute.options()).andReturn(mockOptions);
+ expect(compute.get(GLOBAL_OPERATION_ID, expectedOptions)).andReturn(
+ Operation.fromPb(serviceMockReturnsOptions, globalOperation.toPb().setStatus("PENDING")));
+ replay(compute);
+ initializeOperation();
+ assertFalse(operation.isDone());
+ verify(compute);
+ }
+ @Test
+ public void testIsDone_NotExists() throws Exception {
+ initializeExpectedOperation(3);
+ Compute.OperationOption[] expectedOptions =
+ {Compute.OperationOption.fields(Compute.OperationField.STATUS)};
+ expect(compute.options()).andReturn(mockOptions);
+ expect(compute.get(GLOBAL_OPERATION_ID, expectedOptions)).andReturn(globalOperation);
+ replay(compute);
+ initializeOperation();
+ assertTrue(operation.isDone());
+ verify(compute);
+ }
+
+ @Test
+ public void testReload() throws Exception {
+ initializeExpectedOperation(5);
+ expect(compute.options()).andReturn(mockOptions);
+ expect(compute.get(GLOBAL_OPERATION_ID)).andReturn(globalOperation);
+ replay(compute);
+ initializeOperation();
+ Operation updatedOperation = operation.reload();
+ compareOperation(globalOperation, updatedOperation);
+ verify(compute);
+ }
+
+ @Test
+ public void testReloadNull() throws Exception {
+ initializeExpectedOperation(3);
+ expect(compute.options()).andReturn(mockOptions);
+ expect(compute.get(GLOBAL_OPERATION_ID)).andReturn(null);
+ replay(compute);
+ initializeOperation();
+ assertNull(operation.reload());
+ verify(compute);
+ }
+
+ @Test
+ public void testReloadWithOptions() throws Exception {
+ initializeExpectedOperation(5);
+ expect(compute.options()).andReturn(mockOptions);
+ expect(compute.get(GLOBAL_OPERATION_ID, Compute.OperationOption.fields()))
+ .andReturn(globalOperation);
+ replay(compute);
+ initializeOperation();
+ Operation updatedOperation = operation.reload(Compute.OperationOption.fields());
+ compareOperation(globalOperation, updatedOperation);
+ verify(compute);
+ }
+
+ private void compareOperation(Operation expected, Operation value) {
+ assertEquals(expected, value);
+ assertEquals(expected.compute().options(), value.compute().options());
+ assertEquals(expected.creationTimestamp(), value.creationTimestamp());
+ assertEquals(expected.operationId(), value.operationId());
+ assertEquals(expected.clientOperationId(), value.clientOperationId());
+ assertEquals(expected.operationType(), value.operationType());
+ assertEquals(expected.targetLink(), value.targetLink());
+ assertEquals(expected.targetId(), value.targetId());
+ assertEquals(expected.status(), value.status());
+ assertEquals(expected.statusMessage(), value.statusMessage());
+ assertEquals(expected.user(), value.user());
+ assertEquals(expected.progress(), value.progress());
+ assertEquals(expected.insertTime(), value.insertTime());
+ assertEquals(expected.startTime(), value.startTime());
+ assertEquals(expected.endTime(), value.endTime());
+ assertEquals(expected.errors(), value.errors());
+ assertEquals(expected.warnings(), value.warnings());
+ assertEquals(expected.httpErrorStatusCode(), value.httpErrorStatusCode());
+ assertEquals(expected.httpErrorMessage(), value.httpErrorMessage());
+ assertEquals(expected.description(), value.description());
+ assertEquals(expected.hashCode(), value.hashCode());
+ }
+}
diff --git a/gcloud-java-compute/src/test/java/com/google/gcloud/compute/SerializationTest.java b/gcloud-java-compute/src/test/java/com/google/gcloud/compute/SerializationTest.java
index 74c062fd6c27..a73cf860810f 100644
--- a/gcloud-java-compute/src/test/java/com/google/gcloud/compute/SerializationTest.java
+++ b/gcloud-java-compute/src/test/java/com/google/gcloud/compute/SerializationTest.java
@@ -36,6 +36,7 @@
public class SerializationTest {
+ private static final Compute COMPUTE = ComputeOptions.builder().projectId("p").build().service();
private static final String ID = "42";
private static final Long CREATION_TIMESTAMP = 1453293540000L;
private static final String DESCRIPTION = "description";
@@ -113,7 +114,50 @@ public class SerializationTest {
private static final LicenseId LICENSE_ID = LicenseId.of("project", "license");
private static final Boolean CHARGES_USE_FEE = true;
private static final License LICENSE = new License(LICENSE_ID, CHARGES_USE_FEE);
-
+ private static final GlobalOperationId GLOBAL_OPERATION_ID =
+ GlobalOperationId.of("project", "op");
+ private static final ZoneOperationId ZONE_OPERATION_ID =
+ ZoneOperationId.of("project", "zone", "op");
+ private static final RegionOperationId REGION_OPERATION_ID =
+ RegionOperationId.of("project", "region", "op");
+ private static final Operation GLOBAL_OPERATION =
+ new Operation.Builder(COMPUTE).operationId(GLOBAL_OPERATION_ID).build();
+ private static final Operation ZONE_OPERATION =
+ new Operation.Builder(COMPUTE).operationId(ZONE_OPERATION_ID).build();
+ private static final Operation REGION_OPERATION =
+ new Operation.Builder(COMPUTE).operationId(REGION_OPERATION_ID).build();
+ private static final Compute.DiskTypeOption DISK_TYPE_OPTION =
+ Compute.DiskTypeOption.fields();
+ private static final Compute.DiskTypeFilter DISK_TYPE_FILTER =
+ Compute.DiskTypeFilter.equals(Compute.DiskTypeField.SELF_LINK, "selfLink");
+ private static final Compute.DiskTypeListOption DISK_TYPE_LIST_OPTION =
+ Compute.DiskTypeListOption.filter(DISK_TYPE_FILTER);
+ private static final Compute.DiskTypeAggregatedListOption DISK_TYPE_AGGREGATED_LIST_OPTION =
+ Compute.DiskTypeAggregatedListOption.filter(DISK_TYPE_FILTER);
+ private static final Compute.MachineTypeOption MACHINE_TYPE_OPTION =
+ Compute.MachineTypeOption.fields();
+ private static final Compute.MachineTypeFilter MACHINE_TYPE_FILTER =
+ Compute.MachineTypeFilter.equals(Compute.MachineTypeField.SELF_LINK, "selfLink");
+ private static final Compute.MachineTypeListOption MACHINE_TYPE_LIST_OPTION =
+ Compute.MachineTypeListOption.filter(MACHINE_TYPE_FILTER);
+ private static final Compute.MachineTypeAggregatedListOption MACHINE_TYPE_AGGREGATED_LIST_OPTION =
+ Compute.MachineTypeAggregatedListOption.filter(MACHINE_TYPE_FILTER);
+ private static final Compute.RegionOption REGION_OPTION = Compute.RegionOption.fields();
+ private static final Compute.RegionFilter REGION_FILTER =
+ Compute.RegionFilter.equals(Compute.RegionField.SELF_LINK, "selfLink");
+ private static final Compute.RegionListOption REGION_LIST_OPTION =
+ Compute.RegionListOption.filter(REGION_FILTER);
+ private static final Compute.ZoneOption ZONE_OPTION = Compute.ZoneOption.fields();
+ private static final Compute.ZoneFilter ZONE_FILTER =
+ Compute.ZoneFilter.equals(Compute.ZoneField.SELF_LINK, "selfLink");
+ private static final Compute.ZoneListOption ZONE_LIST_OPTION =
+ Compute.ZoneListOption.filter(ZONE_FILTER);
+ private static final Compute.LicenseOption LICENSE_OPTION = Compute.LicenseOption.fields();
+ private static final Compute.OperationOption OPERATION_OPTION = Compute.OperationOption.fields();
+ private static final Compute.OperationFilter OPERATION_FILTER =
+ Compute.OperationFilter.equals(Compute.OperationField.SELF_LINK, "selfLink");
+ private static final Compute.OperationListOption OPERATION_LIST_OPTION =
+ Compute.OperationListOption.filter(OPERATION_FILTER);
@Test
public void testServiceOptions() throws Exception {
ComputeOptions options = ComputeOptions.builder()
@@ -135,7 +179,13 @@ public void testServiceOptions() throws Exception {
@Test
public void testModelAndRequests() throws Exception {
Serializable[] objects = {DISK_TYPE_ID, DISK_TYPE, MACHINE_TYPE_ID, MACHINE_TYPE, REGION_ID,
- REGION, ZONE_ID, ZONE, LICENSE_ID, LICENSE, DEPRECATION_STATUS};
+ REGION, ZONE_ID, ZONE, LICENSE_ID, LICENSE, DEPRECATION_STATUS, GLOBAL_OPERATION_ID,
+ REGION_OPERATION_ID, ZONE_OPERATION_ID, GLOBAL_OPERATION, REGION_OPERATION, ZONE_OPERATION,
+ DISK_TYPE_OPTION, DISK_TYPE_FILTER, DISK_TYPE_LIST_OPTION, DISK_TYPE_AGGREGATED_LIST_OPTION,
+ MACHINE_TYPE_OPTION, MACHINE_TYPE_FILTER, MACHINE_TYPE_LIST_OPTION,
+ MACHINE_TYPE_AGGREGATED_LIST_OPTION, REGION_OPTION, REGION_FILTER, REGION_LIST_OPTION,
+ ZONE_OPTION, ZONE_FILTER, ZONE_LIST_OPTION, LICENSE_OPTION, OPERATION_OPTION,
+ OPERATION_FILTER, OPERATION_LIST_OPTION};
for (Serializable obj : objects) {
Object copy = serializeAndDeserialize(obj);
assertEquals(obj, obj);
diff --git a/gcloud-java-compute/src/test/java/com/google/gcloud/compute/it/ITComputeTest.java b/gcloud-java-compute/src/test/java/com/google/gcloud/compute/it/ITComputeTest.java
index 5bc2589e6244..ea316f521b29 100644
--- a/gcloud-java-compute/src/test/java/com/google/gcloud/compute/it/ITComputeTest.java
+++ b/gcloud-java-compute/src/test/java/com/google/gcloud/compute/it/ITComputeTest.java
@@ -29,8 +29,11 @@
import com.google.gcloud.compute.License;
import com.google.gcloud.compute.LicenseId;
import com.google.gcloud.compute.MachineType;
+import com.google.gcloud.compute.Operation;
import com.google.gcloud.compute.Region;
+import com.google.gcloud.compute.RegionOperationId;
import com.google.gcloud.compute.Zone;
+import com.google.gcloud.compute.ZoneOperationId;
import com.google.gcloud.compute.testing.RemoteComputeHelper;
import org.junit.BeforeClass;
@@ -62,7 +65,6 @@ public static void beforeClass() throws InterruptedException {
@Test
public void testGetDiskType() {
DiskType diskType = compute.getDiskType(ZONE, DISK_TYPE);
- // todo(mziccard): uncomment or remove once #695 is closed
// assertNotNull(diskType.id());
assertEquals(ZONE, diskType.diskTypeId().zone());
assertEquals(DISK_TYPE, diskType.diskTypeId().diskType());
@@ -76,7 +78,6 @@ public void testGetDiskType() {
public void testGetDiskTypeWithSelectedFields() {
DiskType diskType = compute.getDiskType(ZONE, DISK_TYPE,
Compute.DiskTypeOption.fields(Compute.DiskTypeField.CREATION_TIMESTAMP));
- // todo(mziccard): uncomment or remove once #695 is closed
// assertNotNull(diskType.id());
assertEquals(ZONE, diskType.diskTypeId().zone());
assertEquals(DISK_TYPE, diskType.diskTypeId().diskType());
@@ -93,7 +94,6 @@ public void testListDiskTypes() {
assertTrue(diskTypeIterator.hasNext());
while(diskTypeIterator.hasNext()) {
DiskType diskType = diskTypeIterator.next();
- // todo(mziccard): uncomment or remove once #695 is closed
// assertNotNull(diskType.id());
assertNotNull(diskType.diskTypeId());
assertEquals(ZONE, diskType.diskTypeId().zone());
@@ -148,7 +148,6 @@ public void testAggregatedListDiskTypes() {
assertTrue(diskTypeIterator.hasNext());
while(diskTypeIterator.hasNext()) {
DiskType diskType = diskTypeIterator.next();
- // todo(mziccard): uncomment or remove once #695 is closed
// assertNotNull(diskType.id());
assertNotNull(diskType.diskTypeId());
assertNotNull(diskType.creationTimestamp());
@@ -447,4 +446,190 @@ public void testListZonesWithFilter() {
assertEquals(ZONE, zoneIterator.next().zoneId().zone());
assertFalse(zoneIterator.hasNext());
}
+
+ @Test
+ public void testListGlobalOperations() {
+ Page operationPage = compute.listGlobalOperations();
+ Iterator operationIterator = operationPage.iterateAll();
+ while(operationIterator.hasNext()) {
+ Operation operation = operationIterator.next();
+ assertNotNull(operation.id());
+ assertNotNull(operation.operationId());
+ // todo(mziccard): uncomment or remove once #727 is closed
+ // assertNotNull(operation.creationTimestamp());
+ assertNotNull(operation.operationType());
+ assertNotNull(operation.status());
+ assertNotNull(operation.user());
+ }
+ }
+
+ @Test
+ public void testListGlobalOperationsWithSelectedFields() {
+ Page operationPage =
+ compute.listGlobalOperations(Compute.OperationListOption.fields(Compute.OperationField.ID));
+ Iterator operationIterator = operationPage.iterateAll();
+ while(operationIterator.hasNext()) {
+ Operation operation = operationIterator.next();
+ assertNotNull(operation.id());
+ assertNotNull(operation.operationId());
+ assertNull(operation.operationType());
+ assertNull(operation.targetLink());
+ assertNull(operation.targetId());
+ assertNull(operation.creationTimestamp());
+ assertNull(operation.operationType());
+ assertNull(operation.status());
+ assertNull(operation.statusMessage());
+ assertNull(operation.user());
+ assertNull(operation.progress());
+ assertNull(operation.description());
+ assertNull(operation.insertTime());
+ assertNull(operation.startTime());
+ assertNull(operation.endTime());
+ assertNull(operation.warnings());
+ assertNull(operation.httpErrorMessage());
+ }
+ }
+
+ @Test
+ public void testListGlobalOperationsWithFilter() {
+ Page operationPage = compute.listGlobalOperations(Compute.OperationListOption.filter(
+ Compute.OperationFilter.equals(Compute.OperationField.STATUS, "DONE")));
+ Iterator operationIterator = operationPage.iterateAll();
+ while(operationIterator.hasNext()) {
+ Operation operation = operationIterator.next();
+ assertNotNull(operation.id());
+ assertNotNull(operation.operationId());
+ // todo(mziccard): uncomment or remove once #727 is closed
+ // assertNotNull(operation.creationTimestamp());
+ assertNotNull(operation.operationType());
+ assertEquals(Operation.Status.DONE, operation.status());
+ assertNotNull(operation.user());
+ }
+ }
+
+ @Test
+ public void testListRegionOperations() {
+ Page operationPage = compute.listRegionOperations(REGION);
+ Iterator operationIterator = operationPage.iterateAll();
+ while(operationIterator.hasNext()) {
+ Operation operation = operationIterator.next();
+ assertNotNull(operation.id());
+ assertNotNull(operation.operationId());
+ assertEquals(REGION, operation.operationId().region());
+ // assertNotNull(operation.creationTimestamp());
+ assertNotNull(operation.operationType());
+ assertNotNull(operation.status());
+ assertNotNull(operation.user());
+ }
+ }
+
+ @Test
+ public void testListRegionOperationsWithSelectedFields() {
+ Page operationPage = compute.listRegionOperations(REGION,
+ Compute.OperationListOption.fields(Compute.OperationField.ID));
+ Iterator operationIterator = operationPage.iterateAll();
+ while(operationIterator.hasNext()) {
+ Operation operation = operationIterator.next();
+ assertNotNull(operation.id());
+ assertNotNull(operation.operationId());
+ assertEquals(REGION, operation.operationId().region());
+ assertNull(operation.operationType());
+ assertNull(operation.targetLink());
+ assertNull(operation.targetId());
+ assertNull(operation.creationTimestamp());
+ assertNull(operation.operationType());
+ assertNull(operation.status());
+ assertNull(operation.statusMessage());
+ assertNull(operation.user());
+ assertNull(operation.progress());
+ assertNull(operation.description());
+ assertNull(operation.insertTime());
+ assertNull(operation.startTime());
+ assertNull(operation.endTime());
+ assertNull(operation.warnings());
+ assertNull(operation.httpErrorMessage());
+ }
+ }
+
+ @Test
+ public void testListRegionOperationsWithFilter() {
+ Page operationPage = compute.listRegionOperations(REGION,
+ Compute.OperationListOption.filter(Compute.OperationFilter.equals(
+ Compute.OperationField.STATUS, "DONE")));
+ Iterator operationIterator = operationPage.iterateAll();
+ while(operationIterator.hasNext()) {
+ Operation operation = operationIterator.next();
+ assertNotNull(operation.id());
+ assertNotNull(operation.operationId());
+ assertEquals(REGION, operation.operationId().region());
+ // todo(mziccard): uncomment or remove once #727 is closed
+ // assertNotNull(operation.creationTimestamp());
+ assertNotNull(operation.operationType());
+ assertEquals(Operation.Status.DONE, operation.status());
+ assertNotNull(operation.user());
+ }
+ }
+
+ @Test
+ public void testListZoneOperations() {
+ Page operationPage = compute.listZoneOperations(ZONE);
+ Iterator operationIterator = operationPage.iterateAll();
+ while(operationIterator.hasNext()) {
+ Operation operation = operationIterator.next();
+ assertNotNull(operation.id());
+ assertNotNull(operation.operationId());
+ assertEquals(ZONE, operation.operationId().zone());
+ // assertNotNull(operation.creationTimestamp());
+ assertNotNull(operation.operationType());
+ assertNotNull(operation.status());
+ assertNotNull(operation.user());
+ }
+ }
+
+ @Test
+ public void testListZoneOperationsWithSelectedFields() {
+ Page operationPage = compute.listZoneOperations(ZONE,
+ Compute.OperationListOption.fields(Compute.OperationField.ID));
+ Iterator operationIterator = operationPage.iterateAll();
+ while(operationIterator.hasNext()) {
+ Operation operation = operationIterator.next();
+ assertNotNull(operation.id());
+ assertNotNull(operation.operationId());
+ assertEquals(ZONE, operation.operationId().zone());
+ assertNull(operation.operationType());
+ assertNull(operation.targetLink());
+ assertNull(operation.targetId());
+ assertNull(operation.creationTimestamp());
+ assertNull(operation.operationType());
+ assertNull(operation.status());
+ assertNull(operation.statusMessage());
+ assertNull(operation.user());
+ assertNull(operation.progress());
+ assertNull(operation.description());
+ assertNull(operation.insertTime());
+ assertNull(operation.startTime());
+ assertNull(operation.endTime());
+ assertNull(operation.warnings());
+ assertNull(operation.httpErrorMessage());
+ }
+ }
+
+ @Test
+ public void testListZoneOperationsWithFilter() {
+ Page operationPage = compute.listZoneOperations(ZONE,
+ Compute.OperationListOption.filter(Compute.OperationFilter.equals(
+ Compute.OperationField.STATUS, "DONE")));
+ Iterator operationIterator = operationPage.iterateAll();
+ while(operationIterator.hasNext()) {
+ Operation operation = operationIterator.next();
+ assertNotNull(operation.id());
+ assertNotNull(operation.operationId());
+ assertEquals(ZONE, operation.operationId().zone());
+ // todo(mziccard): uncomment or remove once #727 is closed
+ // assertNotNull(operation.creationTimestamp());
+ assertNotNull(operation.operationType());
+ assertEquals(Operation.Status.DONE, operation.status());
+ assertNotNull(operation.user());
+ }
+ }
}