{
+ void consume(A a) throws Throwable;
+ }
+
+ /**
+ * Define a function which has a void return. This is definition is absolutely not pure and only
+ * exists because some methods on the public api for storage have void return type.
+ */
+ @FunctionalInterface
+ interface VoidFunction {
+ void apply() throws Throwable;
+ }
+}
diff --git a/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/GracefulConformanceEnforcement.java b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/GracefulConformanceEnforcement.java
new file mode 100644
index 0000000000..2fd4f90bb1
--- /dev/null
+++ b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/GracefulConformanceEnforcement.java
@@ -0,0 +1,107 @@
+/*
+ * 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.storage.conformance.retry;
+
+import static org.junit.Assert.assertNotNull;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.io.CharStreams;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.Set;
+import org.junit.AssumptionViolatedException;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+/**
+ * As the adherence of {@link com.google.cloud.storage.Storage} to the retry conformance test suite
+ * is an ongoing effort, we need a way in which those tests which are not yet in compliance do not
+ * server as blockers for other features and commits.
+ *
+ * This class provides a transparent means of enforcing the reporting of failed tests when ran in
+ * a CI environment. When a test is run, if it fails for any reason the test name will be checked
+ * against a list of known complying tests. If the tests name is missing from the known list, then
+ * the failure will be wrapped in an assumption failure to show up as a skipped test rather than a
+ * failed one.
+ */
+final class GracefulConformanceEnforcement implements TestRule {
+
+ private final String testName;
+ private final Set testNamesWhichShouldSucceed;
+
+ public GracefulConformanceEnforcement(String testName) {
+ this.testName = testName;
+ this.testNamesWhichShouldSucceed = loadTestNamesWhichShouldSucceed();
+ }
+
+ @Override
+ public Statement apply(Statement base, Description description) {
+ return new Statement() {
+ @Override
+ public void evaluate() throws Throwable {
+ try {
+ base.evaluate();
+ } catch (AssumptionViolatedException e) {
+ // pass through any assumption/ignore errors as they are
+ throw e;
+ } catch (Throwable t) {
+ if (testNamesWhichShouldSucceed.contains(testName)) {
+ throw t;
+ } else {
+ if (isRunningInCI()) {
+ throw new AssumptionViolatedException(
+ String.format(
+ "Test %s is not expected to succeed yet, downgrading failure to ignored.",
+ testName),
+ t);
+ } else {
+ throw t;
+ }
+ }
+ }
+ }
+ };
+ }
+
+ private static boolean isRunningInCI() {
+ return "test".equals(System.getenv("JOB_TYPE"))
+ || "integration".equals(System.getenv("JOB_TYPE"));
+ }
+
+ private static Set loadTestNamesWhichShouldSucceed() {
+ ClassLoader cl = Thread.currentThread().getContextClassLoader();
+ InputStream inputStream =
+ cl.getResourceAsStream(
+ "com/google/cloud/storage/conformance/retry/testNamesWhichShouldSucceed.txt");
+ assertNotNull(inputStream);
+ try {
+ return CharStreams.readLines(new InputStreamReader(inputStream)).stream()
+ .map(String::trim)
+ .filter(s -> !s.isEmpty() && !s.startsWith("#"))
+ .collect(ImmutableSet.toImmutableSet());
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ } finally {
+ try {
+ inputStream.close();
+ } catch (IOException ignore) {
+ }
+ }
+ }
+}
diff --git a/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/ITRetryConformanceTest.java b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/ITRetryConformanceTest.java
new file mode 100644
index 0000000000..73f15112b5
--- /dev/null
+++ b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/ITRetryConformanceTest.java
@@ -0,0 +1,441 @@
+/*
+ * 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.storage.conformance.retry;
+
+import static com.google.cloud.storage.PackagePrivateMethodWorkarounds.blobCopyWithStorage;
+import static com.google.cloud.storage.PackagePrivateMethodWorkarounds.bucketCopyWithStorage;
+import static com.google.cloud.storage.conformance.retry.Ctx.ctx;
+import static com.google.cloud.storage.conformance.retry.State.empty;
+import static java.util.Objects.requireNonNull;
+import static org.junit.Assert.assertNotNull;
+
+import com.google.cloud.conformance.storage.v1.InstructionList;
+import com.google.cloud.conformance.storage.v1.Method;
+import com.google.cloud.conformance.storage.v1.RetryTest;
+import com.google.cloud.conformance.storage.v1.RetryTests;
+import com.google.cloud.storage.Storage;
+import com.google.cloud.storage.conformance.retry.Functions.CtxFunction;
+import com.google.common.base.Charsets;
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.util.JsonFormat;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.math.BigInteger;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+import java.util.function.BiPredicate;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import org.junit.AssumptionViolatedException;
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized.Parameters;
+
+/**
+ * Load and dynamically generate a series of test cases to verify if the {@link Storage} and
+ * associated high level classes adhere to expected retry behavior.
+ *
+ * This class dynamically generates test cases based on resources from the
+ * google-cloud-conformance-tests artifact and a set of defined mappings from {@link
+ * RpcMethodMappings}.
+ */
+@RunWith(ParallelParameterized.class)
+public class ITRetryConformanceTest {
+ private static final Logger LOGGER = Logger.getLogger(ITRetryConformanceTest.class.getName());
+
+ @ClassRule public static final TestBench TEST_BENCH = TestBench.newBuilder().build();
+
+ @Rule(order = 1)
+ public final GracefulConformanceEnforcement gracefulConformanceEnforcement;
+
+ @Rule(order = 2)
+ public final RetryTestFixture retryTestFixture;
+
+ private final TestRetryConformance testRetryConformance;
+ private final RpcMethodMapping mapping;
+
+ public ITRetryConformanceTest(
+ TestRetryConformance testRetryConformance, RpcMethodMapping mapping) {
+ this.testRetryConformance = testRetryConformance;
+ this.mapping = mapping;
+ this.gracefulConformanceEnforcement =
+ new GracefulConformanceEnforcement(testRetryConformance.getTestName());
+ this.retryTestFixture =
+ new RetryTestFixture(CleanupStrategy.ALWAYS, TEST_BENCH, testRetryConformance);
+ }
+
+ /**
+ * Run an individual test case. 1. Create two storage clients, one for setup/teardown and one for
+ * test execution 2. Run setup 3. Run test 4. Run teardown
+ */
+ @Test
+ public void test() throws Throwable {
+ Storage nonTestStorage = retryTestFixture.getNonTestStorage();
+ Storage testStorage = retryTestFixture.getTestStorage();
+
+ Ctx ctx = ctx(nonTestStorage, empty());
+
+ LOGGER.fine("Running setup...");
+ Ctx postSetupCtx =
+ mapping.getSetup().apply(ctx, testRetryConformance).leftMap(s -> testStorage);
+ LOGGER.fine("Running setup complete");
+
+ LOGGER.fine("Running test...");
+ Ctx postTestCtx =
+ getReplaceStorageInObjectsFromCtx()
+ .andThen(mapping.getTest())
+ .apply(postSetupCtx, testRetryConformance)
+ .leftMap(s -> nonTestStorage);
+ LOGGER.fine("Running test complete");
+
+ LOGGER.fine("Running teardown...");
+ getReplaceStorageInObjectsFromCtx()
+ .andThen(mapping.getTearDown())
+ .apply(postTestCtx, testRetryConformance);
+ LOGGER.fine("Running teardown complete");
+ }
+
+ /**
+ * Load all of the tests and return a {@code Collection} representing the set of tests.
+ * Each entry in the returned collection is the set of parameters to the constructor of this test
+ * class.
+ *
+ * The results of this method will then be run by JUnit's Parameterized test runner
+ */
+ @Parameters(name = "{0}")
+ public static Collection testCases() throws IOException {
+ RetryTestCaseResolver resolver =
+ RetryTestCaseResolver.newBuilder()
+ .setRetryTestsJsonResourcePath(
+ "com/google/cloud/conformance/storage/v1/retry_tests.json")
+ .setMappings(new RpcMethodMappings())
+ .setHost(TEST_BENCH.getBaseUri().replaceAll("https?://", ""))
+ .setTestAllowFilter(RetryTestCaseResolver.includeAll())
+ .build();
+
+ return resolver.getRetryTestCases().stream()
+ .map(rtc -> new Object[] {rtc.testRetryConformance, rtc.rpcMethodMapping})
+ .collect(ImmutableList.toImmutableList());
+ }
+
+ /**
+ * When a "higher level object" ({@link com.google.cloud.storage.Bucket}, {@link
+ * com.google.cloud.storage.Blob}, etc.) is created as part of setup it keeps a reference to the
+ * instance of {@link Storage} used to create it. When we run our tests we need the instance of
+ * {@link Storage} to be the instance with the headers to signal the retry test.
+ *
+ * The function returned will inspect the {@link State} and create copies of any "higher level
+ * objects" which are present replacing the instance of {@link Storage} from the provided ctx.
+ */
+ private static CtxFunction getReplaceStorageInObjectsFromCtx() {
+ return (ctx, c) -> {
+ State s = ctx.getState();
+ if (s.hasBucket()) {
+ s = s.with(bucketCopyWithStorage(s.getBucket(), ctx.getStorage()));
+ }
+ if (s.hasBlob()) {
+ s = s.with(blobCopyWithStorage(s.getBlob(), ctx.getStorage()));
+ }
+ final State state = s;
+ return ctx.map(x -> state);
+ };
+ }
+
+ /**
+ * Helper class which encapsulates all the logic necessary to resolve and crete a test case for
+ * each defined scenario from google-cloud-conformance-tests and our defined {@link
+ * RpcMethodMappings}.
+ */
+ private static final class RetryTestCaseResolver {
+ private static final String HEX_SHUFFLE_SEED_OVERRIDE =
+ System.getProperty("HEX_SHUFFLE_SEED_OVERRIDE");
+
+ private final String retryTestsJsonResourcePath;
+ private final RpcMethodMappings mappings;
+ private final BiPredicate testAllowFilter;
+ private final Random rand;
+ private final String host;
+
+ RetryTestCaseResolver(
+ String retryTestsJsonResourcePath,
+ RpcMethodMappings mappings,
+ BiPredicate testAllowFilter,
+ Random rand,
+ String host) {
+ this.retryTestsJsonResourcePath = retryTestsJsonResourcePath;
+ this.mappings = mappings;
+ this.testAllowFilter = testAllowFilter;
+ this.rand = rand;
+ this.host = host;
+ }
+
+ /** Load, permute and generate all RetryTestCases which are to be run in this suite */
+ List getRetryTestCases() throws IOException {
+ RetryTests retryTests = loadRetryTestsDefinition();
+
+ // sort the defined RetryTest by id, so we have a stable ordering while generating cases.
+ List retryTestCases =
+ retryTests.getRetryTestsList().stream()
+ .sorted(Comparator.comparingInt(RetryTest::getId))
+ .collect(Collectors.toList());
+
+ List testCases = generateTestCases(mappings, retryTestCases);
+
+ // Shuffle our test cases to ensure we don't have any between case ordering weirdness
+ Collections.shuffle(testCases, rand);
+
+ validateGeneratedTestCases(mappings, testCases);
+
+ return testCases;
+ }
+
+ /** Load the defined scenarios from google-cloud-conformance-tests */
+ private RetryTests loadRetryTestsDefinition() throws IOException {
+ ClassLoader cl = Thread.currentThread().getContextClassLoader();
+
+ InputStream dataJson = cl.getResourceAsStream(retryTestsJsonResourcePath);
+ assertNotNull(
+ String.format("Unable to load test definition: %s", retryTestsJsonResourcePath),
+ dataJson);
+
+ InputStreamReader reader = new InputStreamReader(dataJson, Charsets.UTF_8);
+ RetryTests.Builder testBuilder = RetryTests.newBuilder();
+ JsonFormat.parser().merge(reader, testBuilder);
+ return testBuilder.build();
+ }
+
+ /** Permute the RetryTest, Instructions and methods with our mappings */
+ private List generateTestCases(
+ RpcMethodMappings rpcMethodMappings, List retryTests) {
+
+ List testCases = new ArrayList<>();
+ for (RetryTest testCase : retryTests) {
+ for (InstructionList instructionList : testCase.getCasesList()) {
+ for (Method method : testCase.getMethodsList()) {
+ String methodName = method.getName();
+ RpcMethod key = RpcMethod.storage.lookup.get(methodName);
+ assertNotNull(
+ String.format("Unable to resolve RpcMethod for value '%s'", methodName), key);
+ // get all RpcMethodMappings which are defined for key
+ List mappings =
+ rpcMethodMappings.get(key).stream()
+ .sorted(Comparator.comparingInt(RpcMethodMapping::getMappingId))
+ .collect(Collectors.toList());
+ // if we don't have any mappings defined for the provide key, generate a case that when
+ // run reports an ignored test. This is done for the sake of completeness and to be
+ // aware of a lack of mapping.
+ if (mappings.isEmpty()) {
+ TestRetryConformance testRetryConformance =
+ new TestRetryConformance(
+ host,
+ testCase.getId(),
+ method,
+ instructionList,
+ testCase.getPreconditionProvided(),
+ false);
+ if (testAllowFilter.test(key, testRetryConformance)) {
+ testCases.add(
+ new RetryTestCase(testRetryConformance, RpcMethodMapping.notImplemented(key)));
+ }
+ } else {
+ for (RpcMethodMapping mapping : mappings) {
+ TestRetryConformance testRetryConformance =
+ new TestRetryConformance(
+ host,
+ testCase.getId(),
+ method,
+ instructionList,
+ testCase.getPreconditionProvided(),
+ testCase.getExpectSuccess(),
+ mapping.getMappingId());
+ // check that this case is allowed based on the provided filter
+ if (testAllowFilter.test(key, testRetryConformance)) {
+ // check that the defined mapping is applicable to the case we've resolved.
+ // Many mappings are conditionally valid and depend on the defined case.
+ if (mapping.getApplicable().test(testRetryConformance)) {
+ testCases.add(new RetryTestCase(testRetryConformance, mapping));
+ } else {
+ // when the mapping is determined to not be applicable to this case, generate
+ // a synthetic mapping which will report as an ignored test. This is done for
+ // the sake of completeness.
+ RpcMethodMapping build =
+ mapping
+ .toBuilder()
+ .withSetup(CtxFunction.identity())
+ .withTest(
+ (s, c) -> {
+ throw new AssumptionViolatedException(
+ "applicability predicate evaluated to false");
+ })
+ .withTearDown(CtxFunction.identity())
+ .build();
+ testCases.add(new RetryTestCase(testRetryConformance, build));
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ return testCases;
+ }
+
+ private void validateGeneratedTestCases(
+ RpcMethodMappings rpcMethodMappings, List data) {
+ Set unusedMappings =
+ rpcMethodMappings.differenceMappingIds(
+ data.stream()
+ .map(rtc -> rtc.testRetryConformance.getMappingId())
+ .collect(Collectors.toSet()));
+
+ if (!unusedMappings.isEmpty()) {
+ LOGGER.warning(
+ String.format(
+ "Declared but unused mappings with ids: [%s]",
+ Joiner.on(", ").join(unusedMappings)));
+ }
+ }
+
+ static Builder newBuilder() {
+ return new Builder();
+ }
+
+ /** Filtering predicate in which all test cases will be included and run. */
+ static BiPredicate includeAll() {
+ return (m, c) -> true;
+ }
+
+ /**
+ * Filtering predicate in which only those test cases which match up to the specified {@code
+ * mappingId} will be included and run.
+ */
+ static BiPredicate individualMapping(int mappingId) {
+ return (m, c) -> c.getMappingId() == mappingId;
+ }
+
+ static final class Builder {
+ private String retryTestsJsonResourcePath;
+ private RpcMethodMappings mappings;
+ private String host;
+ private BiPredicate testAllowFilter;
+ private final Random rand;
+
+ public Builder() {
+ this.rand = resolveRand();
+ }
+
+ /**
+ * Set the resource path of where to resolve the retry_tests.json from
+ * google-cloud-conformance-tests
+ */
+ public Builder setRetryTestsJsonResourcePath(String retryTestsJsonResourcePath) {
+ this.retryTestsJsonResourcePath = retryTestsJsonResourcePath;
+ return this;
+ }
+
+ /** Set the defined mappings which are to be used in test generation */
+ public Builder setMappings(RpcMethodMappings mappings) {
+ this.mappings = requireNonNull(mappings, "mappings must be non null");
+ return this;
+ }
+
+ /** Set the host string of where the testbench will be available during a test run */
+ public Builder setHost(String host) {
+ this.host = host;
+ return this;
+ }
+
+ /**
+ * Set the allow filter for determining if a particular {@link RpcMethod} and {@link
+ * TestRetryConformance} should be included in the generated test suite.
+ */
+ public Builder setTestAllowFilter(
+ BiPredicate testAllowFilter) {
+ this.testAllowFilter = requireNonNull(testAllowFilter, "testAllowFilter must be non null");
+ return this;
+ }
+
+ public RetryTestCaseResolver build() {
+ return new RetryTestCaseResolver(
+ requireNonNull(
+ retryTestsJsonResourcePath, "retryTestsJsonResourcePath must be non null"),
+ requireNonNull(mappings, "mappings must be non null"),
+ requireNonNull(testAllowFilter, "testAllowList must be non null"),
+ rand,
+ host);
+ }
+
+ /**
+ * As part of test generation and execution we are shuffling the order to ensure there is no
+ * ordering dependency between individual cases. Given this fact, we report the seed used for
+ * performing the shuffle. If an explicit seed is provided via environment variable that will
+ * take precedence.
+ */
+ private static Random resolveRand() {
+ try {
+ long seed;
+ if (HEX_SHUFFLE_SEED_OVERRIDE != null) {
+ LOGGER.info(
+ "Shuffling test order using Random with override seed: "
+ + HEX_SHUFFLE_SEED_OVERRIDE);
+ seed = new BigInteger(HEX_SHUFFLE_SEED_OVERRIDE.replace("0x", ""), 16).longValue();
+ } else {
+ seed =
+ SecureRandom.getInstanceStrong()
+ .longs(100)
+ .reduce((first, second) -> second)
+ .orElseThrow(
+ () -> {
+ throw new IllegalStateException("Unable to generate seed");
+ });
+ String msg =
+ String.format("Shuffling test order using Random with seed: 0x%016X", seed);
+ LOGGER.info(msg);
+ }
+ return new Random(seed);
+ } catch (NoSuchAlgorithmException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+ }
+
+ /**
+ * Simple typed tuple class to bind together a {@link TestRetryConformance} and {@link
+ * RpcMethodMapping} during resolution.
+ */
+ private static final class RetryTestCase {
+ private final TestRetryConformance testRetryConformance;
+ private final RpcMethodMapping rpcMethodMapping;
+
+ RetryTestCase(TestRetryConformance testRetryConformance, RpcMethodMapping rpcMethodMapping) {
+ this.testRetryConformance = testRetryConformance;
+ this.rpcMethodMapping = rpcMethodMapping;
+ }
+ }
+}
diff --git a/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/ParallelParameterized.java b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/ParallelParameterized.java
new file mode 100644
index 0000000000..3d27ab902d
--- /dev/null
+++ b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/ParallelParameterized.java
@@ -0,0 +1,81 @@
+/*
+ * 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.storage.conformance.retry;
+
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Phaser;
+import java.util.concurrent.ThreadFactory;
+import java.util.logging.Logger;
+import org.junit.runners.Parameterized;
+import org.junit.runners.model.RunnerScheduler;
+
+/**
+ * Extends off the provided {@link Parameterized} runner provided by junit, only augmenting which
+ * scheduler is used so that tests can run in parallel by using a thread pool.
+ */
+public final class ParallelParameterized extends Parameterized {
+
+ public ParallelParameterized(Class klass) throws Throwable {
+ super(klass);
+ this.setScheduler(new ParallelScheduler());
+ }
+
+ private static class ParallelScheduler implements RunnerScheduler {
+ private static final Logger LOGGER = Logger.getLogger(ParallelScheduler.class.getName());
+
+ private final Phaser childCounter;
+ private final ExecutorService executorService;
+
+ private ParallelScheduler() {
+ ThreadFactory threadFactory =
+ new ThreadFactoryBuilder()
+ .setDaemon(true)
+ .setNameFormat("parallel-test-runner-%02d")
+ .build();
+ // attempt to leave some space for the testbench server running alongside these tests
+ int coreCount = Runtime.getRuntime().availableProcessors() - 2;
+ int threadCount = Math.max(2, coreCount);
+ LOGGER.info("Using up to " + threadCount + " threads to run tests.");
+ executorService = Executors.newFixedThreadPool(threadCount, threadFactory);
+ childCounter = new Phaser();
+ }
+
+ @Override
+ public void schedule(Runnable childStatement) {
+ childCounter.register();
+ executorService.submit(
+ () -> {
+ try {
+ childStatement.run();
+ } finally {
+ childCounter.arrive();
+ }
+ });
+ }
+
+ @Override
+ public void finished() {
+ try {
+ childCounter.awaitAdvance(0);
+ } finally {
+ executorService.shutdownNow();
+ }
+ }
+ }
+}
diff --git a/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/RetryTestFixture.java b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/RetryTestFixture.java
new file mode 100644
index 0000000000..cb0415c1e7
--- /dev/null
+++ b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/RetryTestFixture.java
@@ -0,0 +1,163 @@
+/*
+ * 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.storage.conformance.retry;
+
+import static org.junit.Assert.assertTrue;
+
+import com.google.api.gax.retrying.RetrySettings;
+import com.google.api.gax.rpc.FixedHeaderProvider;
+import com.google.cloud.NoCredentials;
+import com.google.cloud.conformance.storage.v1.InstructionList;
+import com.google.cloud.conformance.storage.v1.Method;
+import com.google.cloud.storage.Storage;
+import com.google.cloud.storage.StorageOptions;
+import com.google.cloud.storage.conformance.retry.TestBench.RetryTestResource;
+import com.google.common.collect.ImmutableMap;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import java.util.Map;
+import java.util.logging.Logger;
+import org.junit.AssumptionViolatedException;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+/**
+ * A JUnit 4 {@link TestRule} which integrates with {@link TestBench} and {@link
+ * TestRetryConformance} to provide transparent lifecycle integration of setup/validation/cleanup of
+ * {@code /retry_test} resources. This rule expects to be bound as an {@link org.junit.Rule @Rule}
+ * field.
+ *
+ * Provides pre-configured instances of {@link Storage} for setup/teardown & test.
+ */
+final class RetryTestFixture implements TestRule {
+ private static final Logger LOGGER = Logger.getLogger(RetryTestFixture.class.getName());
+
+ private final CleanupStrategy cleanupStrategy;
+ private final TestBench testBench;
+ private final TestRetryConformance testRetryConformance;
+
+ private RetryTestResource retryTest;
+ private Storage nonTestStorage;
+ private Storage testStorage;
+
+ RetryTestFixture(
+ CleanupStrategy cleanupStrategy,
+ TestBench testBench,
+ TestRetryConformance testRetryConformance) {
+ this.cleanupStrategy = cleanupStrategy;
+ this.testBench = testBench;
+ this.testRetryConformance = testRetryConformance;
+ }
+
+ public Storage getNonTestStorage() {
+ if (nonTestStorage == null) {
+ this.nonTestStorage = newStorage(false);
+ }
+ return nonTestStorage;
+ }
+
+ public Storage getTestStorage() {
+ if (testStorage == null) {
+ this.testStorage = newStorage(true);
+ }
+ return testStorage;
+ }
+
+ @Override
+ public Statement apply(final Statement base, Description description) {
+ return new Statement() {
+ @Override
+ public void evaluate() throws Throwable {
+ boolean testSuccess = false;
+ boolean testSkipped = false;
+ try {
+ LOGGER.finer("Setting up retry_test resource...");
+ RetryTestResource retryTestResource =
+ newRetryTestResource(
+ testRetryConformance.getMethod(), testRetryConformance.getInstruction());
+ retryTest = testBench.createRetryTest(retryTestResource);
+ LOGGER.fine("Setting up retry_test resource complete");
+ base.evaluate();
+ testSuccess = true;
+ } catch (AssumptionViolatedException e) {
+ testSkipped = true;
+ throw e;
+ } finally {
+ LOGGER.fine("Verifying end state of retry_test resource...");
+ try {
+ if (testSuccess && retryTest != null) {
+ RetryTestResource postTestState = testBench.getRetryTest(retryTest);
+ assertTrue("expected completed to be true, but was false", postTestState.completed);
+ }
+ } finally {
+ LOGGER.fine("Verifying end state of retry_test resource complete");
+ if ((shouldCleanup(testSuccess, testSkipped)) && retryTest != null) {
+ testBench.deleteRetryTest(retryTest);
+ retryTest = null;
+ }
+ }
+ }
+ }
+ };
+ }
+
+ private boolean shouldCleanup(boolean testSuccess, boolean testSkipped) {
+ return cleanupStrategy == CleanupStrategy.ALWAYS
+ || ((testSuccess || testSkipped) && cleanupStrategy == CleanupStrategy.ONLY_ON_SUCCESS);
+ }
+
+ private static RetryTestResource newRetryTestResource(Method m, InstructionList l) {
+ RetryTestResource resource = new RetryTestResource();
+ resource.instructions = new JsonObject();
+ JsonArray instructions = new JsonArray();
+ for (String s : l.getInstructionsList()) {
+ instructions.add(s);
+ }
+ resource.instructions.add(m.getName(), instructions);
+ return resource;
+ }
+
+ private Storage newStorage(boolean forTest) {
+ StorageOptions.Builder builder =
+ StorageOptions.newBuilder()
+ .setHost(testBench.getBaseUri())
+ .setCredentials(NoCredentials.getInstance())
+ .setProjectId("conformance-tests");
+ if (forTest) {
+ builder.setHeaderProvider(
+ new FixedHeaderProvider() {
+ @Override
+ public Map getHeaders() {
+ return ImmutableMap.of(
+ "x-retry-test-id", retryTest.id, "User-Agent", "java-conformance-tests/");
+ }
+ });
+ } else {
+ builder
+ .setHeaderProvider(
+ new FixedHeaderProvider() {
+ @Override
+ public Map getHeaders() {
+ return ImmutableMap.of("User-Agent", "java-conformance-tests/");
+ }
+ })
+ .setRetrySettings(RetrySettings.newBuilder().setMaxAttempts(1).build());
+ }
+ return builder.build().getService();
+ }
+}
diff --git a/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/RpcMethod.java b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/RpcMethod.java
new file mode 100644
index 0000000000..2227e6bf76
--- /dev/null
+++ b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/RpcMethod.java
@@ -0,0 +1,166 @@
+/*
+ * 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.storage.conformance.retry;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+interface RpcMethod {
+
+ String getFullyQualifiedMethodName();
+
+ /**
+ * Enumerate the hierarchy of storage rpc methods.
+ *
+ * These class names intentionally do not follow java convention, because they are mapping
+ * directly to lower level values.
+ */
+ final class storage {
+ private static String getFullQualifiedMethodName(Enum e) {
+ return String.format("storage.%s.%s", e.getClass().getSimpleName(), e.name());
+ }
+
+ enum bucket_acl implements RpcMethod {
+ delete,
+ get,
+ insert,
+ list,
+ patch,
+ update;
+
+ @Override
+ public String getFullyQualifiedMethodName() {
+ return getFullQualifiedMethodName(this);
+ }
+ }
+
+ enum buckets implements RpcMethod {
+ delete,
+ get,
+ insert,
+ list,
+ patch,
+ update,
+ getIamPolicy,
+ lockRetentionPolicy,
+ setIamPolicy,
+ testIamPermissions;
+
+ @Override
+ public String getFullyQualifiedMethodName() {
+ return getFullQualifiedMethodName(this);
+ }
+ }
+
+ enum default_object_acl implements RpcMethod {
+ delete,
+ get,
+ insert,
+ list,
+ patch,
+ update;
+
+ @Override
+ public String getFullyQualifiedMethodName() {
+ return getFullQualifiedMethodName(this);
+ }
+ }
+
+ enum hmacKey implements RpcMethod {
+ delete,
+ get,
+ list,
+ update,
+ create;
+
+ @Override
+ public String getFullyQualifiedMethodName() {
+ return getFullQualifiedMethodName(this);
+ }
+ }
+
+ enum notifications implements RpcMethod {
+ delete,
+ get,
+ insert,
+ list;
+
+ @Override
+ public String getFullyQualifiedMethodName() {
+ return getFullQualifiedMethodName(this);
+ }
+ }
+
+ enum object_acl implements RpcMethod {
+ delete,
+ get,
+ insert,
+ list,
+ patch,
+ update;
+
+ @Override
+ public String getFullyQualifiedMethodName() {
+ return getFullQualifiedMethodName(this);
+ }
+ }
+
+ enum objects implements RpcMethod {
+ delete,
+ get,
+ insert,
+ list,
+ patch,
+ update,
+ compose,
+ rewrite,
+ copy;
+
+ @Override
+ public String getFullyQualifiedMethodName() {
+ return getFullQualifiedMethodName(this);
+ }
+ }
+
+ enum serviceaccount implements RpcMethod {
+ get;
+
+ @Override
+ public String getFullyQualifiedMethodName() {
+ return getFullQualifiedMethodName(this);
+ }
+ }
+
+ // create a map, which can be used to do a reverse lookup of an RpcMethod by its associated
+ // string value.
+ static final Map lookup =
+ Stream.>of(
+ Arrays.stream(bucket_acl.values()),
+ Arrays.stream(buckets.values()),
+ Arrays.stream(default_object_acl.values()),
+ Arrays.stream(hmacKey.values()),
+ Arrays.stream(notifications.values()),
+ Arrays.stream(object_acl.values()),
+ Arrays.stream(objects.values()),
+ Arrays.stream(serviceaccount.values()))
+ .flatMap(Function.identity()) // .flatten()
+ .collect(Collectors.toMap(RpcMethod::getFullyQualifiedMethodName, Function.identity()));
+ }
+}
diff --git a/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/RpcMethodMapping.java b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/RpcMethodMapping.java
new file mode 100644
index 0000000000..28e5c6edf5
--- /dev/null
+++ b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/RpcMethodMapping.java
@@ -0,0 +1,199 @@
+/*
+ * 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.storage.conformance.retry;
+
+import static com.google.common.collect.Sets.newHashSet;
+import static java.util.Objects.requireNonNull;
+import static org.junit.Assert.fail;
+
+import com.google.cloud.storage.StorageException;
+import com.google.cloud.storage.conformance.retry.CtxFunctions.ResourceSetup;
+import com.google.cloud.storage.conformance.retry.Functions.CtxFunction;
+import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.Immutable;
+import java.util.HashSet;
+import java.util.function.Predicate;
+import org.junit.AssumptionViolatedException;
+
+/**
+ * Immutable class which represents a mapping between an {@link RpcMethod} and a method in the
+ * public {@code com.google.cloud.storage} API.
+ *
+ * This class defines a semi-declarative why in which mappings can be declared independent of the
+ * actual environment & state necessary to actually invoke a method.
+ *
+ * @see ITRetryConformanceTest#test()
+ * @see RpcMethodMappings
+ */
+@Immutable
+final class RpcMethodMapping {
+
+ private final int mappingId;
+ private final RpcMethod method;
+ private final Predicate applicable;
+ private final CtxFunction setup;
+ private final CtxFunction test;
+ private final CtxFunction tearDown;
+
+ RpcMethodMapping(
+ int mappingId,
+ RpcMethod method,
+ Predicate applicable,
+ CtxFunction setup,
+ CtxFunction test,
+ CtxFunction tearDown) {
+ this.mappingId = mappingId;
+ this.method = method;
+ this.applicable = applicable;
+ this.setup = setup;
+ this.test = test;
+ this.tearDown = tearDown;
+ }
+
+ public int getMappingId() {
+ return mappingId;
+ }
+
+ public RpcMethod getMethod() {
+ return method;
+ }
+
+ public Predicate getApplicable() {
+ return applicable;
+ }
+
+ public CtxFunction getSetup() {
+ return setup;
+ }
+
+ public CtxFunction getTest() {
+ return (ctx, c) -> {
+ if (c.isExpectSuccess()) {
+ return test.apply(ctx, c);
+ } else {
+ try {
+ test.apply(ctx, c);
+ fail("expected failure, but succeeded");
+ } catch (StorageException e) {
+ // We expect an exception to be thrown by mapping and test retry conformance config
+ // Verify that the exception we received is actually what we expect.
+ boolean matchExpectedCode = false;
+ int code = e.getCode();
+ HashSet instructions = newHashSet(c.getInstruction().getInstructionsList());
+ if (instructions.contains("return-503") && code == 503) {
+ matchExpectedCode = true;
+ }
+ if (instructions.contains("return-400") && code == 400) {
+ matchExpectedCode = true;
+ }
+ if (instructions.contains("return-401") && code == 401) {
+ matchExpectedCode = true;
+ }
+ if (instructions.contains("return-reset-connection") && code == 0) {
+ matchExpectedCode = true;
+ }
+
+ if (matchExpectedCode) {
+ return ctx;
+ } else {
+ throw e;
+ }
+ }
+ }
+ throw new IllegalStateException(
+ "Unable to determine applicability of mapping for provided TestCaseConfig");
+ };
+ }
+
+ public CtxFunction getTearDown() {
+ return tearDown;
+ }
+
+ public Builder toBuilder() {
+ return new Builder(mappingId, method, applicable, setup, test, tearDown);
+ }
+
+ static Builder newBuilder(int mappingId, RpcMethod method) {
+ Preconditions.checkArgument(mappingId >= 1, "mappingId must be >= 1, but was %d", mappingId);
+ return new Builder(mappingId, method);
+ }
+
+ static RpcMethodMapping notImplemented(RpcMethod method) {
+ return new Builder(0, method)
+ .withTest(
+ (s, c) -> {
+ throw new AssumptionViolatedException("not implemented");
+ })
+ .build();
+ }
+
+ static final class Builder {
+
+ private final int mappingId;
+ private final RpcMethod method;
+ private final Predicate applicable;
+ private final CtxFunction setup;
+ private final CtxFunction test;
+ private CtxFunction tearDown;
+
+ Builder(int mappingId, RpcMethod method) {
+ this(mappingId, method, x -> true, ResourceSetup.defaultSetup, null, CtxFunction.identity());
+ }
+
+ private Builder(
+ int mappingId,
+ RpcMethod method,
+ Predicate applicable,
+ CtxFunction setup,
+ CtxFunction test,
+ CtxFunction tearDown) {
+ this.mappingId = mappingId;
+ this.method = method;
+ this.applicable = applicable;
+ this.setup = setup;
+ this.test = test;
+ this.tearDown = tearDown;
+ }
+
+ public Builder withApplicable(Predicate applicable) {
+ return new Builder(mappingId, method, applicable, setup, test, tearDown);
+ }
+
+ public Builder withSetup(CtxFunction setup) {
+ return new Builder(mappingId, method, applicable, setup, null, tearDown);
+ }
+
+ public Builder withTest(CtxFunction test) {
+ return new Builder(mappingId, method, applicable, setup, test, CtxFunction.identity());
+ }
+
+ public Builder withTearDown(CtxFunction tearDown) {
+ this.tearDown = tearDown;
+ return this;
+ }
+
+ public RpcMethodMapping build() {
+ return new RpcMethodMapping(
+ mappingId,
+ requireNonNull(method, "method must be non null"),
+ requireNonNull(applicable, "applicable must be non null"),
+ requireNonNull(setup, "setup must be non null"),
+ requireNonNull(test, "test must be non null"),
+ requireNonNull(tearDown, "tearDown must be non null"));
+ }
+ }
+}
diff --git a/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/RpcMethodMappings.java b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/RpcMethodMappings.java
new file mode 100644
index 0000000000..3644fbb0ad
--- /dev/null
+++ b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/RpcMethodMappings.java
@@ -0,0 +1,1942 @@
+/*
+ * 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.storage.conformance.retry;
+
+import static com.google.cloud.storage.conformance.retry.CtxFunctions.Local.blobIdWithoutGeneration;
+import static com.google.cloud.storage.conformance.retry.CtxFunctions.Local.blobInfoWithGenerationZero;
+import static com.google.cloud.storage.conformance.retry.CtxFunctions.Local.blobInfoWithoutGeneration;
+import static com.google.cloud.storage.conformance.retry.CtxFunctions.Local.bucketInfo;
+import static com.google.common.base.Predicates.not;
+import static com.google.common.collect.Lists.newArrayList;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.google.cloud.Policy;
+import com.google.cloud.ReadChannel;
+import com.google.cloud.WriteChannel;
+import com.google.cloud.storage.Acl.User;
+import com.google.cloud.storage.Blob;
+import com.google.cloud.storage.Bucket;
+import com.google.cloud.storage.HmacKey.HmacKeyState;
+import com.google.cloud.storage.HttpMethod;
+import com.google.cloud.storage.Storage;
+import com.google.cloud.storage.Storage.BlobGetOption;
+import com.google.cloud.storage.Storage.BlobSourceOption;
+import com.google.cloud.storage.Storage.BlobTargetOption;
+import com.google.cloud.storage.Storage.BlobWriteOption;
+import com.google.cloud.storage.Storage.BucketSourceOption;
+import com.google.cloud.storage.Storage.BucketTargetOption;
+import com.google.cloud.storage.Storage.ComposeRequest;
+import com.google.cloud.storage.Storage.CopyRequest;
+import com.google.cloud.storage.Storage.SignUrlOption;
+import com.google.cloud.storage.Storage.UriScheme;
+import com.google.cloud.storage.conformance.retry.CtxFunctions.Local;
+import com.google.cloud.storage.conformance.retry.CtxFunctions.Rpc;
+import com.google.cloud.storage.conformance.retry.RpcMethod.storage.bucket_acl;
+import com.google.cloud.storage.conformance.retry.RpcMethod.storage.buckets;
+import com.google.cloud.storage.conformance.retry.RpcMethod.storage.default_object_acl;
+import com.google.cloud.storage.conformance.retry.RpcMethod.storage.hmacKey;
+import com.google.cloud.storage.conformance.retry.RpcMethod.storage.object_acl;
+import com.google.cloud.storage.conformance.retry.RpcMethod.storage.objects;
+import com.google.cloud.storage.conformance.retry.RpcMethod.storage.serviceaccount;
+import com.google.cloud.storage.conformance.retry.RpcMethodMappings.Mappings.BucketAcl;
+import com.google.cloud.storage.conformance.retry.RpcMethodMappings.Mappings.Buckets;
+import com.google.cloud.storage.conformance.retry.RpcMethodMappings.Mappings.DefaultObjectAcl;
+import com.google.cloud.storage.conformance.retry.RpcMethodMappings.Mappings.HmacKey;
+import com.google.cloud.storage.conformance.retry.RpcMethodMappings.Mappings.Notification;
+import com.google.cloud.storage.conformance.retry.RpcMethodMappings.Mappings.ObjectAcl;
+import com.google.cloud.storage.conformance.retry.RpcMethodMappings.Mappings.Objects;
+import com.google.cloud.storage.conformance.retry.RpcMethodMappings.Mappings.ServiceAccount;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.MultimapBuilder;
+import com.google.common.collect.Multimaps;
+import com.google.common.collect.Sets;
+import com.google.common.io.ByteStreams;
+import com.google.errorprone.annotations.Immutable;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+import java.net.URL;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.WritableByteChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map.Entry;
+import java.util.OptionalInt;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+/**
+ * A class which serves to try and organize all of the {@link RpcMethodMapping} for the retry
+ * conformance tests.
+ *
+ * Individual mappings are grouped via inner classes corresponding to the {@link RpcMethod} for
+ * which they are defined.
+ *
+ *
As part of construction mappingIds are enforced to be unique, throwing an error if not.
+ */
+@Immutable
+@SuppressWarnings("Guava")
+final class RpcMethodMappings {
+ private static final Logger LOGGER = Logger.getLogger(RpcMethodMappings.class.getName());
+
+ static final int _2MiB = 2 * 1024 * 1024;
+ final Multimap funcMap;
+
+ RpcMethodMappings() {
+ ArrayList a = new ArrayList<>();
+
+ BucketAcl.delete(a);
+ BucketAcl.get(a);
+ BucketAcl.insert(a);
+ BucketAcl.list(a);
+ BucketAcl.patch(a);
+
+ Buckets.delete(a);
+ Buckets.get(a);
+ Buckets.insert(a);
+ Buckets.list(a);
+ Buckets.patch(a);
+ Buckets.update(a);
+ Buckets.getIamPolicy(a);
+ Buckets.lockRetentionPolicy(a);
+ Buckets.setIamPolicy(a);
+ Buckets.testIamPermission(a);
+
+ DefaultObjectAcl.delete(a);
+ DefaultObjectAcl.get(a);
+ DefaultObjectAcl.insert(a);
+ DefaultObjectAcl.list(a);
+ DefaultObjectAcl.patch(a);
+ DefaultObjectAcl.update(a);
+
+ HmacKey.delete(a);
+ HmacKey.get(a);
+ HmacKey.list(a);
+ HmacKey.update(a);
+ HmacKey.create(a);
+
+ Notification.delete(a);
+ Notification.get(a);
+ Notification.insert(a);
+ Notification.list(a);
+
+ ObjectAcl.delete(a);
+ ObjectAcl.get(a);
+ ObjectAcl.insert(a);
+ ObjectAcl.list(a);
+ ObjectAcl.patch(a);
+ ObjectAcl.update(a);
+
+ Objects.delete(a);
+ Objects.get(a);
+ Objects.insert(a);
+ Objects.list(a);
+ Objects.patch(a);
+ Objects.update(a);
+ Objects.compose(a);
+ Objects.rewrite(a);
+ Objects.copy(a);
+
+ ServiceAccount.get(a);
+ ServiceAccount.put(a);
+
+ validateMappingDefinitions(a);
+
+ funcMap = Multimaps.index(a, RpcMethodMapping::getMethod);
+ reportMappingSummary();
+ }
+
+ public Collection get(RpcMethod key) {
+ return funcMap.get(key);
+ }
+
+ public Set differenceMappingIds(Set usedMappingIds) {
+ return Sets.difference(
+ funcMap.values().stream().map(RpcMethodMapping::getMappingId).collect(Collectors.toSet()),
+ usedMappingIds);
+ }
+
+ private void validateMappingDefinitions(ArrayList a) {
+ ListMultimap idMappings =
+ MultimapBuilder.hashKeys()
+ .arrayListValues()
+ .build(Multimaps.index(a, RpcMethodMapping::getMappingId));
+ String duplicateIds =
+ idMappings.asMap().entrySet().stream()
+ .filter(e -> e.getValue().size() > 1)
+ .map(Entry::getKey)
+ .map(i -> Integer.toString(i))
+ .collect(Collectors.joining(", "));
+ if (!duplicateIds.isEmpty()) {
+ String message = "duplicate mapping ids present: [" + duplicateIds + "]";
+ throw new IllegalStateException(message);
+ }
+ }
+
+ private void reportMappingSummary() {
+ int mappingCount = funcMap.values().stream().mapToInt(m -> 1).sum();
+ LOGGER.info("Current total number of mappings defined: " + mappingCount);
+ String counts =
+ funcMap.asMap().entrySet().stream()
+ .map(
+ e -> {
+ RpcMethod rpcMethod = e.getKey();
+ Collection mappings = e.getValue();
+ return String.format(
+ "\t%s.%s: %d",
+ rpcMethod
+ .getClass()
+ .getName()
+ .replace("com.google.cloud.storage.conformance.retry.RpcMethod$", "")
+ .replace("$", "."),
+ rpcMethod,
+ mappings.size());
+ })
+ .sorted()
+ .collect(Collectors.joining("\n", "\n", ""));
+ LOGGER.info("Current number of mappings per rpc method: " + counts);
+ OptionalInt max =
+ funcMap.values().stream().map(RpcMethodMapping::getMappingId).mapToInt(i -> i).max();
+ if (max.isPresent()) {
+ LOGGER.info(String.format("Current max mapping index is: %d%n", max.getAsInt()));
+ } else {
+ throw new IllegalStateException("No mappings defined");
+ }
+ }
+
+ static final class Mappings {
+
+ static final class BucketAcl {
+
+ private static void delete(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(1, bucket_acl.delete)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .deleteAcl(c.getBucketName(), User.ofAllUsers()))))
+ .build()); // TODO: Why does this exist, varargs should suffice
+ a.add(
+ RpcMethodMapping.newBuilder(2, bucket_acl.delete)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .deleteAcl(
+ c.getBucketName(),
+ User.ofAllUsers(),
+ BucketSourceOption.userProject(c.getUserProject())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(87, bucket_acl.delete)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .deleteAcl(state.getAcl().getEntity())))))
+ .build());
+ }
+
+ private static void get(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(3, bucket_acl.get)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage().getAcl(c.getBucketName(), User.ofAllUsers()))))
+ .build()); // TODO: Why does this exist, varargs should suffice
+ a.add(
+ RpcMethodMapping.newBuilder(4, bucket_acl.get)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .getAcl(
+ c.getBucketName(),
+ User.ofAllUsers(),
+ BucketSourceOption.userProject(c.getUserProject())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(88, bucket_acl.get)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state.getBucket().getAcl(state.getAcl().getEntity())))))
+ .build());
+ }
+
+ private static void insert(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(5, bucket_acl.insert)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage().createAcl(c.getBucketName(), state.getAcl()))))
+ .build()); // TODO: Why does this exist, varargs should suffice
+ a.add(
+ RpcMethodMapping.newBuilder(6, bucket_acl.insert)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .createAcl(
+ c.getBucketName(),
+ state.getAcl(),
+ BucketSourceOption.userProject(c.getUserProject())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(89, bucket_acl.insert)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(state.getBucket().createAcl(state.getAcl())))))
+ .build());
+ }
+
+ private static void list(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(7, bucket_acl.list)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state -> state.withAcls(ctx.getStorage().listAcls(c.getBucketName()))))
+ .build()); // TODO: Why does this exist, varargs should suffice
+ a.add(
+ RpcMethodMapping.newBuilder(8, bucket_acl.list)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.withAcls(
+ ctx.getStorage()
+ .listAcls(
+ c.getBucketName(),
+ BucketSourceOption.userProject(c.getUserProject())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(90, bucket_acl.list)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(state -> state.withAcls(state.getBucket().listAcls()))))
+ .build());
+ }
+
+ private static void patch(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(9, bucket_acl.patch)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage().updateAcl(c.getBucketName(), state.getAcl()))))
+ .build()); // TODO: Why does this exist, varargs should suffice
+ a.add(
+ RpcMethodMapping.newBuilder(10, bucket_acl.patch)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .updateAcl(
+ c.getBucketName(),
+ state.getAcl(),
+ BucketSourceOption.userProject(c.getUserProject())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(91, bucket_acl.patch)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(state.getBucket().updateAcl(state.getAcl())))))
+ .build());
+ }
+ }
+
+ static final class Buckets {
+ private static void delete(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(11, buckets.delete)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .delete(
+ c.getBucketName(),
+ BucketSourceOption.userProject(c.getUserProject())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(92, buckets.delete)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) -> ctx.map(state -> state.with(state.getBucket().delete()))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(93, buckets.delete)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .delete(Bucket.BucketSourceOption.metagenerationMatch()))))
+ .build());
+ }
+
+ private static void get(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(12, buckets.get)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(state -> state.with(ctx.getStorage().get(c.getBucketName()))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(94, buckets.get)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest((ctx, c) -> ctx.map(state -> state.with(state.getBucket().exists())))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(95, buckets.get)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .exists(Bucket.BucketSourceOption.metagenerationMatch()))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(96, buckets.get)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest((ctx, c) -> ctx.map(state -> state.with(state.getBucket().reload())))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(97, buckets.get)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .reload(Bucket.BucketSourceOption.metagenerationMatch()))))
+ .build());
+ }
+
+ private static void insert(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(14, buckets.insert)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ bucketInfo.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(ctx.getStorage().create(state.getBucketInfo())))))
+ .build());
+ }
+
+ private static void list(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(15, buckets.list)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(state -> state.consume(ctx.getStorage().list(c.getBucketName()))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(98, buckets.list)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest((ctx, c) -> ctx.map(state -> state.consume(state.getBucket().list())))
+ .build());
+ }
+
+ private static void patch(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(17, buckets.patch)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ bucketInfo.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(ctx.getStorage().update(state.getBucketInfo())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(122, buckets.patch)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ bucketInfo.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .update(
+ state.getBucketInfo(),
+ BucketTargetOption.metagenerationMatch())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(101, buckets.patch)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .update(
+ BucketTargetOption.metagenerationMatch())))))
+ .build());
+ }
+
+ private static void update(ArrayList a) {}
+
+ private static void getIamPolicy(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(13, buckets.getIamPolicy)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state -> state.with(ctx.getStorage().getIamPolicy(c.getBucketName()))))
+ .build());
+ }
+
+ private static void lockRetentionPolicy(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(16, buckets.lockRetentionPolicy)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ bucketInfo.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .lockRetentionPolicy(
+ state.getBucketInfo(),
+ BucketTargetOption.metagenerationMatch())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(99, buckets.lockRetentionPolicy)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state -> state.with(state.getBucket().lockRetentionPolicy()))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(100, buckets.lockRetentionPolicy)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .lockRetentionPolicy(
+ BucketTargetOption.metagenerationMatch())))))
+ .build());
+ }
+
+ private static void setIamPolicy(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(18, buckets.setIamPolicy)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .setIamPolicy(
+ c.getBucketName(), Policy.newBuilder().build()))))
+ .build()); // TODO: configure policy
+ }
+
+ private static void testIamPermission(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(19, buckets.testIamPermissions)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.withTestIamPermissionsResults(
+ ctx.getStorage()
+ .testIamPermissions(
+ c.getBucketName(),
+ Collections.singletonList("todo: permissions")))))
+ .build()); // TODO: configure permissions
+ }
+ }
+
+ static final class DefaultObjectAcl {
+
+ private static void delete(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(20, default_object_acl.delete)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .deleteDefaultAcl(
+ c.getBucketName(), state.getAcl().getEntity()))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(102, default_object_acl.delete)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .deleteDefaultAcl(state.getAcl().getEntity())))))
+ .build());
+ }
+
+ private static void get(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(21, default_object_acl.get)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .getDefaultAcl(
+ c.getBucketName(), state.getAcl().getEntity()))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(103, default_object_acl.get)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .getDefaultAcl(state.getAcl().getEntity())))))
+ .build());
+ }
+
+ private static void insert(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(22, default_object_acl.insert)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .createDefaultAcl(c.getBucketName(), state.getAcl()))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(104, default_object_acl.insert)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state.getBucket().createDefaultAcl(state.getAcl())))))
+ .build());
+ }
+
+ private static void list(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(23, default_object_acl.list)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.withAcls(
+ ctx.getStorage().listDefaultAcls(c.getBucketName()))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(105, default_object_acl.list)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state -> state.withAcls(state.getBucket().listDefaultAcls()))))
+ .build());
+ }
+
+ private static void patch(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(24, default_object_acl.patch)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .updateDefaultAcl(c.getBucketName(), state.getAcl()))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(106, default_object_acl.patch)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state.getBucket().updateDefaultAcl(state.getAcl())))))
+ .build());
+ }
+
+ private static void update(ArrayList a) {}
+ }
+
+ static final class HmacKey {
+
+ private static void delete(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(26, hmacKey.delete)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.consume(
+ () ->
+ ctx.getStorage()
+ .deleteHmacKey(state.getHmacKey().getMetadata()))))
+ .build());
+ }
+
+ private static void get(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(27, hmacKey.get)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .getHmacKey(
+ state.getHmacKey().getMetadata().getAccessId()))))
+ .build());
+ }
+
+ private static void list(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(28, hmacKey.list)
+ .withTest(
+ (ctx, c) -> ctx.map(state -> state.consume(ctx.getStorage().listHmacKeys())))
+ .build());
+ }
+
+ private static void update(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(29, hmacKey.update)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .updateHmacKeyState(
+ state.getHmacKey().getMetadata(),
+ HmacKeyState.ACTIVE))))
+ .build()); // TODO: what state should be used in the test?
+ }
+
+ private static void create(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(25, hmacKey.create)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage().createHmacKey(state.getServiceAccount()))))
+ .build());
+ }
+ }
+
+ static final class Notification {
+
+ private static void delete(ArrayList a) {}
+
+ private static void get(ArrayList a) {}
+
+ private static void insert(ArrayList a) {}
+
+ private static void list(ArrayList a) {}
+ }
+
+ static final class ObjectAcl {
+
+ private static void delete(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(30, object_acl.delete)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .deleteAcl(
+ state.getBlobId(), state.getAcl().getEntity())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(62, object_acl.delete)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBlob()
+ .deleteAcl(state.getAcl().getEntity())))))
+ .build());
+ }
+
+ private static void get(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(31, object_acl.get)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .getAcl(
+ state.getBlobId(), state.getAcl().getEntity())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(63, object_acl.get)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state.getBlob().getAcl(state.getAcl().getEntity())))))
+ .build());
+ }
+
+ private static void insert(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(32, object_acl.insert)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .createAcl(state.getBlobId(), state.getAcl())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(64, object_acl.insert)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(state.getBlob().createAcl(state.getAcl())))))
+ .build());
+ }
+
+ private static void list(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(33, object_acl.list)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.withAcls(ctx.getStorage().listAcls(state.getBlobId())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(65, object_acl.list)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(state -> state.withAcls(state.getBlob().listAcls()))))
+ .build());
+ }
+
+ private static void patch(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(34, object_acl.patch)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .updateAcl(state.getBlobId(), state.getAcl())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(66, object_acl.patch)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(state.getBlob().updateAcl(state.getAcl())))))
+ .build());
+ }
+
+ private static void update(ArrayList a) {}
+ }
+
+ static final class Objects {
+
+ private static void delete(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(36, objects.delete)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state -> state.with(ctx.getStorage().delete(state.getBlobId())))))
+ .build()); // TODO: Why does this exist, varargs should suffice
+ a.add(
+ RpcMethodMapping.newBuilder(37, objects.delete)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .delete(
+ state.getBlobId(),
+ BlobSourceOption.metagenerationMatch(1L))))))
+ .build()); // TODO: Correct arg?
+ a.add(
+ RpcMethodMapping.newBuilder(38, objects.delete)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .delete(
+ state.getBlobId().getBucket(),
+ state.getBlobId().getName(),
+ BlobSourceOption.metagenerationMatch(1L))))))
+ .build()); // TODO: Correct arg?
+ a.add(
+ RpcMethodMapping.newBuilder(67, objects.delete)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen((ctx, c) -> ctx.peek(state -> state.getBlob().delete())))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(68, objects.delete)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state ->
+ state
+ .getBlob()
+ .delete(Blob.BlobSourceOption.metagenerationMatch()))))
+ .build());
+ }
+
+ private static void get(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(39, objects.get)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(state -> state.with(ctx.getStorage().get(state.getBlobId())))))
+ .build()); // TODO: Why does this exist, varargs should suffice
+ a.add(
+ RpcMethodMapping.newBuilder(239, objects.get)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ (ctx, c) ->
+ ctx.peek(state -> ctx.getStorage().get(state.getBlob().getBlobId())))
+ .withTearDown(
+ CtxFunctions.ResourceTeardown.object.andThen(
+ CtxFunctions.ResourceTeardown.bucket))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(40, objects.get)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .get(
+ state.getBlobId(),
+ BlobGetOption.metagenerationMatch(1L))))))
+ .build()); // TODO: Correct arg?
+ a.add(
+ RpcMethodMapping.newBuilder(41, objects.get)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .get(
+ state.getBlobId().getBucket(),
+ state.getBlobId().getName(),
+ BlobGetOption.metagenerationMatch(1L))))))
+ .build()); // TODO: Correct arg?
+ a.add(
+ RpcMethodMapping.newBuilder(42, objects.get)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .readAllBytes(
+ state.getBlobId(),
+ BlobSourceOption.metagenerationMatch(1L))))))
+ .build()); // TODO: Correct arg?
+ a.add(
+ RpcMethodMapping.newBuilder(43, objects.get)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .readAllBytes(
+ state.getBlobId().getBucket(),
+ state.getBlobId().getName(),
+ BlobSourceOption.metagenerationMatch(1L))))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(44, objects.get)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state -> {
+ ReadChannel reader =
+ ctx.getStorage().reader(ctx.getState().getBlobId());
+ WritableByteChannel write =
+ Channels.newChannel(NullOutputStream.INSTANCE);
+ ByteStreams.copy(reader, write);
+ })))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(45, objects.get)
+ .withTest(
+ blobIdWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state -> {
+ ReadChannel reader =
+ ctx.getStorage()
+ .reader(
+ ctx.getState().getBlobId().getBucket(),
+ ctx.getState().getBlobId().getName());
+ WritableByteChannel write =
+ Channels.newChannel(NullOutputStream.INSTANCE);
+ ByteStreams.copy(reader, write);
+ })))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(60, objects.get)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) -> ctx.peek(state -> assertTrue(state.getBlob().exists()))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(61, objects.get)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state ->
+ assertTrue(
+ state
+ .getBlob()
+ .exists(Blob.BlobSourceOption.generationMatch())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(69, objects.get)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state -> {
+ Path tmpOutFile =
+ Files.createTempFile(c.getMethod().getName(), ".txt");
+ state
+ .getBlob()
+ .downloadTo(
+ tmpOutFile); // TODO: Why does this exist, varargs
+ // should suffice
+ byte[] downloadedBytes = Files.readAllBytes(tmpOutFile);
+ assertEquals(c.getHelloWorldUtf8Bytes(), downloadedBytes);
+ })))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(70, objects.get)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state -> {
+ Path tmpOutFile =
+ Files.createTempFile(c.getMethod().getName(), ".txt");
+ state
+ .getBlob()
+ .downloadTo(
+ tmpOutFile,
+ Blob.BlobSourceOption.metagenerationMatch());
+ byte[] downloadedBytes = Files.readAllBytes(tmpOutFile);
+ assertEquals(c.getHelloWorldUtf8Bytes(), downloadedBytes);
+ })))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(71, objects.get)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state -> {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ state.getBlob().downloadTo(baos);
+ byte[] downloadedBytes = baos.toByteArray();
+ assertEquals(c.getHelloWorldUtf8Bytes(), downloadedBytes);
+ })))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(72, objects.get)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state -> {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ state
+ .getBlob()
+ .downloadTo(
+ baos, Blob.BlobSourceOption.metagenerationMatch());
+ byte[] downloadedBytes = baos.toByteArray();
+ assertEquals(c.getHelloWorldUtf8Bytes(), downloadedBytes);
+ })))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(73, objects.get)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state -> {
+ byte[] downloadedBytes = state.getBlob().getContent();
+ assertEquals(c.getHelloWorldUtf8Bytes(), downloadedBytes);
+ })))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(74, objects.get)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state -> {
+ byte[] downloadedBytes =
+ state
+ .getBlob()
+ .getContent(
+ Blob.BlobSourceOption.metagenerationMatch());
+ assertEquals(c.getHelloWorldUtf8Bytes(), downloadedBytes);
+ })))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(75, objects.get)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen((ctx, c) -> ctx.peek(state -> state.getBlob().reload())))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(76, objects.get)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state ->
+ state
+ .getBlob()
+ .reload(Blob.BlobSourceOption.metagenerationMatch()))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(107, objects.get)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state -> state.with(state.getBucket().get(c.getObjectName())))))
+ .build()); // TODO: Fill out permutations here
+ }
+
+ private static void insert(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(46, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ blobInfoWithGenerationZero.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .create(
+ ctx.getState().getBlobInfo(),
+ c.getHelloWorldUtf8Bytes(),
+ BlobTargetOption.generationMatch())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(47, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ blobInfoWithGenerationZero.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .create(
+ ctx.getState().getBlobInfo(),
+ c.getHelloWorldUtf8Bytes(),
+ 0,
+ c.getHelloWorldUtf8Bytes().length / 2,
+ BlobTargetOption.generationMatch())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(48, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ blobInfoWithGenerationZero.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .create(
+ ctx.getState().getBlobInfo(),
+ new ByteArrayInputStream(
+ c.getHelloWorldUtf8Bytes()),
+ BlobWriteOption.generationMatch())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(49, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ blobInfoWithGenerationZero.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .createFrom(
+ ctx.getState().getBlobInfo(),
+ new ByteArrayInputStream(
+ c.getHelloWorldUtf8Bytes()),
+ BlobWriteOption.generationMatch())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(50, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ blobInfoWithGenerationZero.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .createFrom(
+ ctx.getState().getBlobInfo(),
+ c.getHelloWorldFilePath(),
+ BlobWriteOption.generationMatch())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(51, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ blobInfoWithGenerationZero.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .createFrom(
+ ctx.getState().getBlobInfo(),
+ c.getHelloWorldFilePath(),
+ _2MiB,
+ BlobWriteOption.generationMatch())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(52, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ blobInfoWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state -> {
+ try (WriteChannel writer =
+ ctx.getStorage().writer(ctx.getState().getBlobInfo())) {
+ writer.write(ByteBuffer.wrap(c.getHelloWorldUtf8Bytes()));
+ }
+ })))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(53, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ blobInfoWithGenerationZero.andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state -> {
+ try (WriteChannel writer =
+ ctx.getStorage()
+ .writer(
+ ctx.getState().getBlobInfo(),
+ BlobWriteOption.generationMatch())) {
+ writer.write(ByteBuffer.wrap(c.getHelloWorldUtf8Bytes()));
+ }
+ })))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(54, objects.insert)
+ .withTest(
+ blobInfoWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state -> {
+ Storage storage = ctx.getStorage();
+ URL signedUrl =
+ storage.signUrl(
+ state.getBlobInfo(),
+ 1,
+ TimeUnit.HOURS,
+ SignUrlOption.httpMethod(HttpMethod.POST),
+ SignUrlOption.withBucketBoundHostname(
+ c.getHost(), UriScheme.HTTP),
+ SignUrlOption.withExtHeaders(
+ ImmutableMap.of("x-goog-resumable", "start")),
+ SignUrlOption.signWith(c.getServiceAccountSigner()),
+ SignUrlOption.withV2Signature());
+ try (WriteChannel writer = storage.writer(signedUrl)) {
+ writer.write(ByteBuffer.wrap(c.getHelloWorldUtf8Bytes()));
+ }
+ })))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(77, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ blobInfoWithoutGeneration
+ .andThen(Rpc.createEmptyBlob)
+ .andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state -> {
+ try (WriteChannel writer = state.getBlob().writer()) {
+ writer.write(ByteBuffer.wrap(c.getHelloWorldUtf8Bytes()));
+ }
+ })))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(78, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ blobInfoWithoutGeneration
+ .andThen(Rpc.createEmptyBlob)
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.peek(
+ state -> {
+ try (WriteChannel writer =
+ state
+ .getBlob()
+ .writer(BlobWriteOption.generationMatch())) {
+ writer.write(ByteBuffer.wrap(c.getHelloWorldUtf8Bytes()));
+ }
+ })))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(108, objects.insert)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .create(c.getObjectName(), c.getHelloWorldUtf8Bytes()))))
+ .build()); // TODO: Fill out permutations here
+ a.add(
+ RpcMethodMapping.newBuilder(109, objects.insert)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .create(
+ c.getObjectName(),
+ c.getHelloWorldUtf8Bytes(),
+ "text/plain);charset=utf-8"))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(110, objects.insert)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .create(
+ c.getObjectName(),
+ new ByteArrayInputStream(c.getHelloWorldUtf8Bytes())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(111, objects.insert)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .create(
+ c.getObjectName(),
+ new ByteArrayInputStream(c.getHelloWorldUtf8Bytes()),
+ "text/plain);charset=utf-8"))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(112, objects.insert)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ blobInfoWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .create(
+ ctx.getState().getBlobInfo(),
+ c.getHelloWorldUtf8Bytes())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(113, objects.insert)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ blobInfoWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .create(
+ ctx.getState().getBlobInfo(),
+ c.getHelloWorldUtf8Bytes(),
+ 0,
+ c.getHelloWorldUtf8Bytes().length / 2)))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(114, objects.insert)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ blobInfoWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .create(
+ ctx.getState().getBlobInfo(),
+ new ByteArrayInputStream(
+ c.getHelloWorldUtf8Bytes()))))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(115, objects.insert)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ blobInfoWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .createFrom(
+ ctx.getState().getBlobInfo(),
+ new ByteArrayInputStream(
+ c.getHelloWorldUtf8Bytes()))))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(116, objects.insert)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ blobInfoWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .createFrom(
+ ctx.getState().getBlobInfo(),
+ c.getHelloWorldFilePath())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(117, objects.insert)
+ .withApplicable(not(TestRetryConformance::isPreconditionsProvided))
+ .withTest(
+ blobInfoWithoutGeneration.andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .createFrom(
+ ctx.getState().getBlobInfo(),
+ c.getHelloWorldFilePath(),
+ _2MiB)))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(118, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .create(
+ c.getObjectName(),
+ c.getHelloWorldUtf8Bytes(),
+ Bucket.BlobTargetOption.generationMatch(1L))))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(119, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .create(
+ c.getObjectName(),
+ c.getHelloWorldUtf8Bytes(),
+ "text/plain);charset=utf-8",
+ Bucket.BlobTargetOption.generationMatch(1L))))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(120, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .create(
+ c.getObjectName(),
+ new ByteArrayInputStream(
+ c.getHelloWorldUtf8Bytes()),
+ Bucket.BlobWriteOption.generationMatch(1L))))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(121, objects.insert)
+ .withApplicable(TestRetryConformance::isPreconditionsProvided)
+ .withTest(
+ bucketInfo
+ .andThen(Rpc.bucket)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBucket()
+ .create(
+ c.getObjectName(),
+ new ByteArrayInputStream(
+ c.getHelloWorldUtf8Bytes()),
+ "text/plain);charset=utf-8",
+ Bucket.BlobWriteOption.generationMatch(1L))))))
+ .build());
+ }
+
+ private static void list(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(55, objects.list)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(state -> state.consume(ctx.getStorage().list(c.getBucketName()))))
+ .build());
+ }
+
+ private static void patch(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(56, objects.patch)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage().update(ctx.getState().getBlob())))))
+ .build()); // TODO: Why does this exist, varargs should suffice
+ a.add(
+ RpcMethodMapping.newBuilder(57, objects.patch)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .update(
+ ctx.getState().getBlob(),
+ BlobTargetOption.metagenerationMatch())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(79, objects.patch)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen((ctx, c) -> ctx.peek(state -> state.getBlob().update())))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(80, objects.patch)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBlob()
+ .update(BlobTargetOption.generationMatch())))))
+ .build()); // TODO: Correct arg?
+ }
+
+ private static void update(ArrayList a) {}
+
+ private static void compose(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(35, objects.compose)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .compose(
+ ComposeRequest.of(
+ c.getBucketName(),
+ newArrayList("blob-part-1", "blob-part-2"),
+ "blob-full")))))
+ .build());
+ }
+
+ private static void rewrite(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(58, objects.rewrite)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ ctx.getStorage()
+ .copy(
+ CopyRequest.of(
+ c.getBucketName(), "blob-source", "blob-target")))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(81, objects.rewrite)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(Local.blobCopy)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(state.getBlob().copyTo(state.getCopyDest())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(82, objects.rewrite)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(Local.blobCopy)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBlob()
+ .copyTo(
+ state.getCopyDest(),
+ Blob.BlobSourceOption.metagenerationMatch())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(83, objects.rewrite)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(Local.blobCopy)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBlob()
+ .copyTo(state.getCopyDest().getBucket())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(84, objects.rewrite)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(Local.blobCopy)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBlob()
+ .copyTo(
+ state.getCopyDest().getBucket(),
+ Blob.BlobSourceOption.metagenerationMatch())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(85, objects.rewrite)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(Local.blobCopy)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBlob()
+ .copyTo(
+ state.getCopyDest().getBucket(),
+ state.getCopyDest().getName())))))
+ .build());
+ a.add(
+ RpcMethodMapping.newBuilder(86, objects.rewrite)
+ .withTest(
+ blobIdWithoutGeneration
+ .andThen(Rpc.blobWithGeneration)
+ .andThen(Local.blobCopy)
+ .andThen(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(
+ state
+ .getBlob()
+ .copyTo(
+ state.getCopyDest().getBucket(),
+ state.getCopyDest().getName(),
+ Blob.BlobSourceOption.metagenerationMatch())))))
+ .build());
+ }
+
+ private static void copy(ArrayList a) {}
+ }
+
+ static final class ServiceAccount {
+
+ private static void get(ArrayList a) {
+ a.add(
+ RpcMethodMapping.newBuilder(59, serviceaccount.get)
+ .withTest(
+ (ctx, c) ->
+ ctx.map(
+ state ->
+ state.with(ctx.getStorage().getServiceAccount(c.getUserProject()))))
+ .build());
+ }
+
+ private static void put(ArrayList a) {}
+ }
+ }
+
+ static final class NullOutputStream extends OutputStream {
+ private static final NullOutputStream INSTANCE = new NullOutputStream();
+
+ @Override
+ public void write(int b) {}
+ }
+}
diff --git a/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/State.java b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/State.java
new file mode 100644
index 0000000000..e1ddb808de
--- /dev/null
+++ b/google-cloud-storage/src/test/java/com/google/cloud/storage/conformance/retry/State.java
@@ -0,0 +1,342 @@
+/*
+ * 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.storage.conformance.retry;
+
+import static java.util.Objects.requireNonNull;
+
+import com.google.api.gax.paging.Page;
+import com.google.cloud.Policy;
+import com.google.cloud.storage.Acl;
+import com.google.cloud.storage.Blob;
+import com.google.cloud.storage.BlobId;
+import com.google.cloud.storage.BlobInfo;
+import com.google.cloud.storage.Bucket;
+import com.google.cloud.storage.BucketInfo;
+import com.google.cloud.storage.CopyWriter;
+import com.google.cloud.storage.HmacKey;
+import com.google.cloud.storage.HmacKey.HmacKeyMetadata;
+import com.google.cloud.storage.ServiceAccount;
+import com.google.cloud.storage.conformance.retry.Functions.VoidFunction;
+import com.google.common.collect.ImmutableMap;
+import com.google.errorprone.annotations.Immutable;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+
+/**
+ * A specialized wrapper around an immutable map allowing for declaration of named get/has/with
+ * methods without the need for individual fields.
+ *
+ * Every mutation returns a copy with the mutation result.
+ *
+ *
Over the course of executing an individual test for a specific mapping some fields will be
+ * updated.
+ *
+ *
This approach was taken after multiple attempts to create more type safe alternatives which
+ * turned into far too much duplication given the possible permutations of state for various
+ * mappings.
+ */
+@Immutable
+final class State {
+
+ private static final State EMPTY = new State();
+ private static final Key KEY_ACL = new Key<>("acl");
+ private static final Key KEY_BLOB = new Key<>("blob");
+ private static final Key KEY_BLOB_ID = new Key<>("blobId");
+ private static final Key KEY_COPY_DEST = new Key<>("copyDest");
+ private static final Key KEY_BLOB_INFO = new Key<>("blobInfo");
+ private static final Key KEY_BOOL = new Key<>("bool");
+ private static final Key KEY_BUCKET = new Key<>("bucket");
+ private static final Key KEY_BUCKET_INFO = new Key<>("bucketInfo");
+ private static final Key KEY_COPY = new Key<>("copy");
+ private static final Key KEY_HMAC_KEY = new Key<>("hmacKey");
+ private static final Key KEY_HMAC_KEY_METADATA = new Key<>("hmacKeyMetadata");
+ private static final Key KEY_POLICY = new Key<>("policy");
+ private static final Key KEY_SERVICE_ACCOUNT = new Key<>("serviceAccount");
+ private static final Key