You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@aurora.apache.org by wf...@apache.org on 2015/04/21 20:54:50 UTC

[1/3] aurora git commit: Require non-default primitive values in StorageEntityUtil.

Repository: aurora
Updated Branches:
  refs/heads/master 3380572a9 -> 449a835e9


http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/storage/mem/MemTaskStoreTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/storage/mem/MemTaskStoreTest.java b/src/test/java/org/apache/aurora/scheduler/storage/mem/MemTaskStoreTest.java
index 83b238f..20c9204 100644
--- a/src/test/java/org/apache/aurora/scheduler/storage/mem/MemTaskStoreTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/storage/mem/MemTaskStoreTest.java
@@ -19,43 +19,46 @@ import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
-import com.google.common.base.Function;
-import com.google.common.base.Optional;
 import com.google.common.collect.FluentIterable;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Maps;
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.twitter.common.inject.Bindings;
+import com.twitter.common.inject.Bindings.KeyFactory;
 import com.twitter.common.quantity.Amount;
 import com.twitter.common.quantity.Time;
 import com.twitter.common.util.concurrent.ExecutorServiceShutdown;
 
-import org.apache.aurora.gen.AssignedTask;
-import org.apache.aurora.gen.Constraint;
+import org.apache.aurora.gen.Attribute;
+import org.apache.aurora.gen.Container;
 import org.apache.aurora.gen.ExecutorConfig;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.JobKey;
-import org.apache.aurora.gen.Metadata;
+import org.apache.aurora.gen.HostAttributes;
+import org.apache.aurora.gen.MaintenanceMode;
+import org.apache.aurora.gen.MesosContainer;
 import org.apache.aurora.gen.ScheduleStatus;
 import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskConfig;
-import org.apache.aurora.gen.TaskConstraint;
-import org.apache.aurora.gen.TaskEvent;
 import org.apache.aurora.gen.TaskQuery;
-import org.apache.aurora.gen.ValueConstraint;
 import org.apache.aurora.scheduler.base.JobKeys;
 import org.apache.aurora.scheduler.base.Query;
 import org.apache.aurora.scheduler.base.Tasks;
+import org.apache.aurora.scheduler.storage.AttributeStore;
+import org.apache.aurora.scheduler.storage.Storage;
 import org.apache.aurora.scheduler.storage.TaskStore.Mutable.TaskMutation;
+import org.apache.aurora.scheduler.storage.db.DbModule;
+import org.apache.aurora.scheduler.storage.entities.IHostAttributes;
 import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
 import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
 import org.apache.aurora.scheduler.storage.testing.StorageEntityUtil;
 import org.junit.Before;
+import org.junit.Ignore;
 import org.junit.Test;
 
 import static org.apache.aurora.gen.ScheduleStatus.RUNNING;
+import static org.apache.aurora.scheduler.base.TaskTestUtil.makeTask;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
@@ -63,38 +66,126 @@ import static org.junit.Assert.assertTrue;
 
 public class MemTaskStoreTest {
 
-  private static final IScheduledTask TASK_A = makeTask("a");
-  private static final IScheduledTask TASK_B = makeTask("b");
-  private static final IScheduledTask TASK_C = makeTask("c");
-  private static final IScheduledTask TASK_D = makeTask("d");
-
-  private MemTaskStore store;
+  private static final IHostAttributes HOST_A = IHostAttributes.build(
+      new HostAttributes(
+          "hostA",
+          ImmutableSet.of(new Attribute("zone", ImmutableSet.of("1a"))))
+          .setSlaveId("slaveIdA")
+          .setMode(MaintenanceMode.NONE));
+  private static final IHostAttributes HOST_B = IHostAttributes.build(
+      new HostAttributes(
+          "hostB",
+          ImmutableSet.of(new Attribute("zone", ImmutableSet.of("1a"))))
+          .setSlaveId("slaveIdB")
+          .setMode(MaintenanceMode.NONE));
+  private static final IScheduledTask TASK_A = createTask("a");
+  private static final IScheduledTask TASK_B =
+      setContainer(createTask("b"), Container.mesos(new MesosContainer()));
+  private static final IScheduledTask TASK_C = createTask("c");
+  private static final IScheduledTask TASK_D = createTask("d");
+
+  private Storage storage;
 
   @Before
   public void setUp() {
-    store = new MemTaskStore();
+    Injector injector = Guice.createInjector(
+        new MemStorageModule(KeyFactory.PLAIN),
+        DbModule.testModule(Bindings.annotatedKeyFactory(MemStorage.Delegated.class)));
+    storage = injector.getInstance(Storage.class);
+    storage.prepare();
+
+    storage.write(new Storage.MutateWork.NoResult.Quiet() {
+      @Override
+      protected void execute(Storage.MutableStoreProvider storeProvider) {
+        AttributeStore.Mutable attributeStore = storeProvider.getAttributeStore();
+        attributeStore.saveHostAttributes(HOST_A);
+        attributeStore.saveHostAttributes(HOST_B);
+      }
+    });
+  }
+
+  private Iterable<IScheduledTask> fetchTasks(final Query.Builder query) {
+    return storage.read(new Storage.Work.Quiet<Iterable<IScheduledTask>>() {
+      @Override
+      public Iterable<IScheduledTask> apply(Storage.StoreProvider storeProvider) {
+        return storeProvider.getTaskStore().fetchTasks(query);
+      }
+    });
+  }
+
+  private void saveTasks(final IScheduledTask... tasks) {
+    saveTasks(ImmutableSet.copyOf(tasks));
+  }
+
+  private void saveTasks(final Set<IScheduledTask> tasks) {
+    storage.write(new Storage.MutateWork.NoResult.Quiet() {
+      @Override
+      protected void execute(Storage.MutableStoreProvider storeProvider) {
+        storeProvider.getUnsafeTaskStore().saveTasks(ImmutableSet.copyOf(tasks));
+      }
+    });
+  }
+
+  private ImmutableSet<IScheduledTask> mutateTasks(
+      final Query.Builder query,
+      final TaskMutation mutation) {
+
+    return storage.write(new Storage.MutateWork.Quiet<ImmutableSet<IScheduledTask>>() {
+      @Override
+      public ImmutableSet<IScheduledTask> apply(Storage.MutableStoreProvider storeProvider) {
+        return storeProvider.getUnsafeTaskStore().mutateTasks(query, mutation);
+      }
+    });
+  }
+
+  private boolean unsafeModifyInPlace(final String taskId, final ITaskConfig taskConfiguration) {
+    return storage.write(new Storage.MutateWork.Quiet<Boolean>() {
+      @Override
+      public Boolean apply(Storage.MutableStoreProvider storeProvider) {
+        return storeProvider.getUnsafeTaskStore().unsafeModifyInPlace(taskId, taskConfiguration);
+      }
+    });
+  }
+
+  private void deleteTasks(final String... taskIds) {
+    storage.write(new Storage.MutateWork.NoResult.Quiet() {
+      @Override
+      protected void execute(Storage.MutableStoreProvider storeProvider) {
+        storeProvider.getUnsafeTaskStore().deleteTasks(ImmutableSet.copyOf(taskIds));
+      }
+    });
+  }
+
+  private void deleteAllTasks() {
+    storage.write(new Storage.MutateWork.NoResult.Quiet() {
+      @Override
+      protected void execute(Storage.MutableStoreProvider storeProvider) {
+        storeProvider.getUnsafeTaskStore().deleteAllTasks();
+      }
+    });
   }
 
   @Test
   public void testSave() {
-    StorageEntityUtil.assertFullyPopulated(TASK_A.newBuilder());
-    store.saveTasks(ImmutableSet.of(TASK_A, TASK_B));
-    assertStoreContents(TASK_A, TASK_B);
+    IScheduledTask aWithHost = setHost(TASK_A, HOST_A);
+    StorageEntityUtil.assertFullyPopulated(aWithHost.newBuilder());
 
-    store.saveTasks(ImmutableSet.of(TASK_C, TASK_D));
-    assertStoreContents(TASK_A, TASK_B, TASK_C, TASK_D);
+    saveTasks(aWithHost, TASK_B);
+    assertStoreContents(aWithHost, TASK_B);
+
+    saveTasks(TASK_C, TASK_D);
+    assertStoreContents(aWithHost, TASK_B, TASK_C, TASK_D);
 
     // Saving the same task should overwrite.
-    IScheduledTask taskAModified =
-        IScheduledTask.build(TASK_A.newBuilder().setStatus(RUNNING));
-    store.saveTasks(ImmutableSet.of(taskAModified));
+    IScheduledTask taskAModified = IScheduledTask.build(aWithHost.newBuilder().setStatus(RUNNING));
+    saveTasks(taskAModified);
     assertStoreContents(taskAModified, TASK_B, TASK_C, TASK_D);
   }
 
   @Test
   public void testQuery() {
     assertStoreContents();
-    store.saveTasks(ImmutableSet.of(TASK_A, TASK_B, TASK_C, TASK_D));
+    saveTasks(TASK_A, TASK_B, TASK_C, TASK_D);
 
     assertQueryResults(Query.taskScoped("b"), TASK_B);
     assertQueryResults(Query.taskScoped("a", "d"), TASK_A, TASK_D);
@@ -105,7 +196,7 @@ public class MemTaskStoreTest {
         Query.unscoped().byStatus(ScheduleStatus.PENDING),
         TASK_A, TASK_B, TASK_C, TASK_D);
     assertQueryResults(
-        Query.instanceScoped(JobKeys.from("role-a", "env-a", "job-a"), 0).active(), TASK_A);
+        Query.instanceScoped(JobKeys.from("role-a", "env-a", "job-a"), 2).active(), TASK_A);
     assertQueryResults(Query.jobScoped(JobKeys.from("role-b", "env-b", "job-b")).active(), TASK_B);
     assertQueryResults(Query.jobScoped(JobKeys.from("role-b", "devel", "job-b")).active());
 
@@ -122,21 +213,34 @@ public class MemTaskStoreTest {
   }
 
   @Test
+  public void testQueryMultipleInstances() {
+    ImmutableSet.Builder<IScheduledTask> tasksBuilder = ImmutableSet.builder();
+    for (int i = 0; i < 100; i++) {
+      ScheduledTask builder = TASK_A.newBuilder();
+      builder.getAssignedTask()
+          .setTaskId("id" + i)
+          .setInstanceId(i);
+      tasksBuilder.add(IScheduledTask.build(builder));
+    }
+    Set<IScheduledTask> tasks = tasksBuilder.build();
+    saveTasks(tasks);
+    assertQueryResults(Query.unscoped(), tasks);
+  }
+
+  @Test
   public void testQueryBySlaveHost() {
-    String hostA = "slaveA";
-    String hostB = "slaveB";
-    final IScheduledTask a = setHost(makeTask("a", "role", "env", "job"), Optional.of(hostA));
-    final IScheduledTask b = setHost(makeTask("b", "role", "env", "job"), Optional.of(hostB));
-    store.saveTasks(ImmutableSet.of(a, b));
+    IScheduledTask a = setHost(makeTask("a", JobKeys.from("role", "env", "job")), HOST_A);
+    IScheduledTask b = setHost(makeTask("b", JobKeys.from("role", "env", "job")), HOST_B);
+    saveTasks(a, b);
 
-    assertQueryResults(Query.slaveScoped(hostA), a);
-    assertQueryResults(Query.slaveScoped(hostA, hostB), a, b);
+    assertQueryResults(Query.slaveScoped(HOST_A.getHost()), a);
+    assertQueryResults(Query.slaveScoped(HOST_A.getHost(), HOST_B.getHost()), a, b);
   }
 
   @Test
   public void testQueryByJobKeys() {
     assertStoreContents();
-    store.saveTasks(ImmutableSet.of(TASK_A, TASK_B, TASK_C, TASK_D));
+    saveTasks(TASK_A, TASK_B, TASK_C, TASK_D);
 
     assertQueryResults(
         Query.jobScoped(ImmutableSet.of(
@@ -147,8 +251,8 @@ public class MemTaskStoreTest {
 
     // Conflicting jobs will produce the result from the last added JobKey
     assertQueryResults(
-          Query.jobScoped(JobKeys.from("role-a", "env-a", "job-a"))
-              .byJobKeys(ImmutableSet.of(JobKeys.from("role-b", "env-b", "job-b"))),
+        Query.jobScoped(JobKeys.from("role-a", "env-a", "job-a"))
+            .byJobKeys(ImmutableSet.of(JobKeys.from("role-b", "env-b", "job-b"))),
         TASK_B);
 
     // The .byJobKeys will override the previous scoping and OR all of the keys.
@@ -170,10 +274,10 @@ public class MemTaskStoreTest {
 
   @Test
   public void testMutate() {
-    store.saveTasks(ImmutableSet.of(TASK_A, TASK_B, TASK_C, TASK_D));
+    saveTasks(TASK_A, TASK_B, TASK_C, TASK_D);
     assertQueryResults(Query.statusScoped(RUNNING));
 
-    store.mutateTasks(Query.taskScoped("a"), new TaskMutation() {
+    mutateTasks(Query.taskScoped("a"), new TaskMutation() {
       @Override
       public IScheduledTask apply(IScheduledTask task) {
         return IScheduledTask.build(task.newBuilder().setStatus(RUNNING));
@@ -184,7 +288,7 @@ public class MemTaskStoreTest {
         Query.statusScoped(RUNNING),
         IScheduledTask.build(TASK_A.newBuilder().setStatus(RUNNING)));
 
-    store.mutateTasks(Query.unscoped(), new TaskMutation() {
+    mutateTasks(Query.unscoped(), new TaskMutation() {
       @Override
       public IScheduledTask apply(IScheduledTask task) {
         return IScheduledTask.build(task.newBuilder().setStatus(ScheduleStatus.ASSIGNED));
@@ -207,59 +311,59 @@ public class MemTaskStoreTest {
             .setExecutorConfig(new ExecutorConfig("aurora", "new_config")));
 
     String taskId = Tasks.id(TASK_A);
-    assertFalse(store.unsafeModifyInPlace(taskId, updated));
+    assertFalse(unsafeModifyInPlace(taskId, updated));
 
-    store.saveTasks(ImmutableSet.of(TASK_A));
-    assertTrue(store.unsafeModifyInPlace(taskId, updated));
+    saveTasks(TASK_A);
+    assertTrue(unsafeModifyInPlace(taskId, updated));
     Query.Builder query = Query.taskScoped(taskId);
     ITaskConfig stored =
-        Iterables.getOnlyElement(store.fetchTasks(query)).getAssignedTask().getTask();
+        Iterables.getOnlyElement(fetchTasks(query)).getAssignedTask().getTask();
     assertEquals(updated, stored);
 
-    store.deleteTasks(ImmutableSet.of(taskId));
-    assertFalse(store.unsafeModifyInPlace(taskId, updated));
+    deleteTasks(taskId);
+    assertFalse(unsafeModifyInPlace(taskId, updated));
   }
 
   @Test
   public void testDelete() {
-    store.saveTasks(ImmutableSet.of(TASK_A, TASK_B, TASK_C, TASK_D));
-    store.deleteTasks(ImmutableSet.of("a"));
+    saveTasks(TASK_A, TASK_B, TASK_C, TASK_D);
+    deleteTasks("a");
     assertStoreContents(TASK_B, TASK_C, TASK_D);
-    store.deleteTasks(ImmutableSet.of("c"));
+    deleteTasks("c");
     assertStoreContents(TASK_B, TASK_D);
-    store.deleteTasks(ImmutableSet.of("b", "d"));
+    deleteTasks("b", "d");
     assertStoreContents();
   }
 
   @Test
   public void testDeleteAll() {
-    store.saveTasks(ImmutableSet.of(TASK_A, TASK_B, TASK_C, TASK_D));
-    store.deleteAllTasks();
+    saveTasks(TASK_A, TASK_B, TASK_C, TASK_D);
+    deleteAllTasks();
     assertStoreContents();
   }
 
   @Test
   public void testConsistentJobIndex() {
-    final IScheduledTask a = makeTask("a", "jim", "test", "job");
-    final IScheduledTask b = makeTask("b", "jim", "test", "job");
-    final IScheduledTask c = makeTask("c", "jim", "test", "job2");
-    final IScheduledTask d = makeTask("d", "joe", "test", "job");
-    final IScheduledTask e = makeTask("e", "jim", "prod", "job");
+    final IScheduledTask a = makeTask("a", JobKeys.from("jim", "test", "job"));
+    final IScheduledTask b = makeTask("b", JobKeys.from("jim", "test", "job"));
+    final IScheduledTask c = makeTask("c", JobKeys.from("jim", "test", "job2"));
+    final IScheduledTask d = makeTask("d", JobKeys.from("joe", "test", "job"));
+    final IScheduledTask e = makeTask("e", JobKeys.from("jim", "prod", "job"));
     final Query.Builder jimsJob = Query.jobScoped(JobKeys.from("jim", "test", "job"));
     final Query.Builder jimsJob2 = Query.jobScoped(JobKeys.from("jim", "test", "job2"));
     final Query.Builder joesJob = Query.jobScoped(JobKeys.from("joe", "test", "job"));
 
-    store.saveTasks(ImmutableSet.of(a, b, c, d, e));
+    saveTasks(a, b, c, d, e);
     assertQueryResults(jimsJob, a, b);
     assertQueryResults(jimsJob2, c);
     assertQueryResults(joesJob, d);
 
-    store.deleteTasks(ImmutableSet.of(Tasks.id(b)));
+    deleteTasks(Tasks.id(b));
     assertQueryResults(jimsJob, a);
     assertQueryResults(jimsJob2, c);
     assertQueryResults(joesJob, d);
 
-    store.mutateTasks(jimsJob, new TaskMutation() {
+    mutateTasks(jimsJob, new TaskMutation() {
       @Override
       public IScheduledTask apply(IScheduledTask task) {
         return IScheduledTask.build(task.newBuilder().setStatus(RUNNING));
@@ -270,15 +374,15 @@ public class MemTaskStoreTest {
     assertQueryResults(jimsJob2, c);
     assertQueryResults(joesJob, d);
 
-    store.deleteTasks(ImmutableSet.of(Tasks.id(d)));
+    deleteTasks(Tasks.id(d));
     assertQueryResults(joesJob);
 
-    store.deleteTasks(ImmutableSet.of(Tasks.id(d)));
+    deleteTasks(Tasks.id(d));
     assertQueryResults(jimsJob, aRunning);
     assertQueryResults(jimsJob2, c);
     assertQueryResults(joesJob);
 
-    store.saveTasks(ImmutableSet.of(b));
+    saveTasks(b);
     assertQueryResults(jimsJob, aRunning, b);
     assertQueryResults(jimsJob2, c);
     assertQueryResults(joesJob);
@@ -286,13 +390,13 @@ public class MemTaskStoreTest {
 
   @Test
   public void testCanonicalTaskConfigs() {
-    IScheduledTask a = makeTask("a", "role", "env", "job");
-    IScheduledTask b = makeTask("a", "role", "env", "job");
-    IScheduledTask c = makeTask("a", "role", "env", "job");
+    IScheduledTask a = createTask("a");
+    IScheduledTask b = createTask("a");
+    IScheduledTask c = createTask("a");
+    saveTasks(a, b, c);
     Set<IScheduledTask> inserted = ImmutableSet.of(a, b, c);
 
-    store.saveTasks(inserted);
-    Set<ITaskConfig> storedConfigs = FluentIterable.from(store.fetchTasks(Query.unscoped()))
+    Set<ITaskConfig> storedConfigs = FluentIterable.from(fetchTasks(Query.unscoped()))
         .transform(Tasks.SCHEDULED_TO_INFO)
         .toSet();
     assertEquals(
@@ -307,9 +411,19 @@ public class MemTaskStoreTest {
         identityMap);
   }
 
-  private static IScheduledTask setHost(IScheduledTask task, Optional<String> host) {
+  private static IScheduledTask setHost(IScheduledTask task, IHostAttributes host) {
     ScheduledTask builder = task.newBuilder();
-    builder.getAssignedTask().setSlaveHost(host.orNull());
+    builder.getAssignedTask()
+        .setSlaveHost(host.getHost())
+        .setSlaveId(host.getSlaveId());
+    return IScheduledTask.build(builder);
+  }
+
+  private static IScheduledTask unsetHost(IScheduledTask task) {
+    ScheduledTask builder = task.newBuilder();
+    builder.getAssignedTask()
+        .setSlaveHost(null)
+        .setSlaveId(null);
     return IScheduledTask.build(builder);
   }
 
@@ -321,14 +435,13 @@ public class MemTaskStoreTest {
 
   @Test
   public void testAddSlaveHost() {
-    final IScheduledTask a = makeTask("a", "role", "env", "job");
-    store.saveTasks(ImmutableSet.of(a));
-    String host = "slaveA";
-    assertQueryResults(Query.slaveScoped(host));
-
-    final IScheduledTask b = setHost(a, Optional.of(host));
-    Set<IScheduledTask> result = store.mutateTasks(Query.taskScoped(Tasks.id(a)),
-        new Function<IScheduledTask, IScheduledTask>() {
+    final IScheduledTask a = createTask("a");
+    saveTasks(a);
+    assertQueryResults(Query.slaveScoped(HOST_A.getHost()));
+
+    final IScheduledTask b = setHost(a, HOST_A);
+    Set<IScheduledTask> result = mutateTasks(Query.taskScoped(Tasks.id(a)),
+        new TaskMutation() {
           @Override
           public IScheduledTask apply(IScheduledTask task) {
             assertEquals(a, task);
@@ -336,13 +449,12 @@ public class MemTaskStoreTest {
           }
         });
     assertEquals(ImmutableSet.of(b), result);
-    assertQueryResults(Query.slaveScoped(host), b);
+    assertQueryResults(Query.slaveScoped(HOST_A.getHost()), b);
 
     // Unrealistic behavior, but proving that the secondary index can handle key mutations.
-    String host2 = "slaveA2";
-    final IScheduledTask c = setHost(b, Optional.of(host2));
-    Set<IScheduledTask> result2 = store.mutateTasks(Query.taskScoped(Tasks.id(a)),
-        new Function<IScheduledTask, IScheduledTask>() {
+    final IScheduledTask c = setHost(b, HOST_B);
+    Set<IScheduledTask> result2 = mutateTasks(Query.taskScoped(Tasks.id(a)),
+        new TaskMutation() {
           @Override
           public IScheduledTask apply(IScheduledTask task) {
             assertEquals(b, task);
@@ -350,24 +462,23 @@ public class MemTaskStoreTest {
           }
         });
     assertEquals(ImmutableSet.of(c), result2);
-    assertQueryResults(Query.slaveScoped(host2), c);
+    assertQueryResults(Query.slaveScoped(HOST_B.getHost()), c);
 
-    store.deleteTasks(ImmutableSet.of(Tasks.id(a)));
-    assertQueryResults(Query.slaveScoped(host));
+    deleteTasks(Tasks.id(a));
+    assertQueryResults(Query.slaveScoped(HOST_B.getHost()));
   }
 
   @Test
   public void testUnsetSlaveHost() {
     // Unrealistic behavior, but proving that the secondary index does not become stale.
 
-    String host = "slaveA";
-    final IScheduledTask a = setHost(makeTask("a", "role", "env", "job"), Optional.of(host));
-    store.saveTasks(ImmutableSet.of(a));
-    assertQueryResults(Query.slaveScoped(host), a);
+    final IScheduledTask a = setHost(createTask("a"), HOST_A);
+    saveTasks(a);
+    assertQueryResults(Query.slaveScoped(HOST_A.getHost()), a);
 
-    final IScheduledTask b = setHost(a, Optional.<String>absent());
-    Set<IScheduledTask> result = store.mutateTasks(Query.taskScoped(Tasks.id(a)),
-        new Function<IScheduledTask, IScheduledTask>() {
+    final IScheduledTask b = unsetHost(a);
+    Set<IScheduledTask> result = mutateTasks(Query.taskScoped(Tasks.id(a)),
+        new TaskMutation() {
           @Override
           public IScheduledTask apply(IScheduledTask task) {
             assertEquals(a, task);
@@ -375,17 +486,16 @@ public class MemTaskStoreTest {
           }
         });
     assertEquals(ImmutableSet.of(b), result);
-    assertQueryResults(Query.slaveScoped(host));
+    assertQueryResults(Query.slaveScoped(HOST_A.getHost()));
     assertQueryResults(Query.taskScoped(Tasks.id(b)), b);
   }
 
   @Test
   public void testTasksOnSameHost() {
-    String host = "slaveA";
-    final IScheduledTask a = setHost(makeTask("a", "role", "env", "job"), Optional.of(host));
-    final IScheduledTask b = setHost(makeTask("b", "role", "env", "job"), Optional.of(host));
-    store.saveTasks(ImmutableSet.of(a, b));
-    assertQueryResults(Query.slaveScoped(host), a, b);
+    final IScheduledTask a = setHost(createTask("a"), HOST_A);
+    final IScheduledTask b = setHost(createTask("b"), HOST_A);
+    saveTasks(a, b);
+    assertQueryResults(Query.slaveScoped(HOST_A.getHost()), a, b);
   }
 
   @Test
@@ -393,16 +503,16 @@ public class MemTaskStoreTest {
     // Ensures that saving a task with an existing task ID is effectively the same as a mutate,
     // and does not result in a duplicate object in the primary or secondary index.
 
-    String host = "slaveA";
-    final IScheduledTask a = setHost(makeTask("a", "role", "env", "job"), Optional.of(host));
-    store.saveTasks(ImmutableSet.of(a));
+    final IScheduledTask a = setHost(createTask("a"), HOST_A);
+    saveTasks(a);
 
     final IScheduledTask updated = setConfigData(a, "new config data");
-    store.saveTasks(ImmutableSet.of(updated));
+    saveTasks(updated);
     assertQueryResults(Query.taskScoped(Tasks.id(a)), updated);
-    assertQueryResults(Query.slaveScoped(host), updated);
+    assertQueryResults(Query.slaveScoped(HOST_A.getHost()), updated);
   }
 
+  @Ignore
   @Test
   public void testReadSecondaryIndexMultipleThreads() throws Exception {
     ExecutorService executor = Executors.newFixedThreadPool(4,
@@ -414,10 +524,10 @@ public class MemTaskStoreTest {
       final int numJobs = 100;
       for (int j = 0; j < numJobs; j++) {
         for (int t = 0; t < numTasks; t++) {
-          builder.add(makeTask("" + j + "-" + t, "role", "env", "name" + j));
+          builder.add(makeTask("" + j + "-" + t, JobKeys.from("role", "env", "name" + j)));
         }
       }
-      store.saveTasks(builder.build());
+      saveTasks(builder.build());
 
       final CountDownLatch read = new CountDownLatch(numJobs);
       for (int j = 0; j < numJobs; j++) {
@@ -425,15 +535,14 @@ public class MemTaskStoreTest {
         executor.submit(new Runnable() {
           @Override
           public void run() {
-            assertNotNull(store.fetchTasks(Query.jobScoped(
-                JobKeys.from("role", "env", "name" + id))));
+            assertNotNull(fetchTasks(Query.jobScoped(JobKeys.from("role", "env", "name" + id))));
             read.countDown();
           }
         });
         executor.submit(new Runnable() {
           @Override
           public void run() {
-            store.saveTasks(ImmutableSet.of(makeTask("TaskNew1" + id)));
+            saveTasks(createTask("TaskNew1" + id));
           }
         });
       }
@@ -453,50 +562,20 @@ public class MemTaskStoreTest {
   }
 
   private void assertQueryResults(Query.Builder query, IScheduledTask... tasks) {
-    assertEquals(
-        ImmutableSet.<IScheduledTask>builder().add(tasks).build(),
-        store.fetchTasks(query));
-  }
-
-  private static IScheduledTask makeTask(String id, String role, String env, String jobName) {
-    return IScheduledTask.build(new ScheduledTask()
-        .setStatus(ScheduleStatus.PENDING)
-        .setTaskEvents(ImmutableList.of(
-            new TaskEvent(100L, ScheduleStatus.ASSIGNED)
-                .setMessage("message")
-                .setScheduler("scheduler")))
-        .setAncestorId("ancestor")
-        .setAssignedTask(new AssignedTask()
-            .setInstanceId(0)
-            .setTaskId(id)
-            .setSlaveId("slave")
-            .setSlaveHost("slavehost")
-            .setAssignedPorts(ImmutableMap.of("http", 1000))
-            .setTask(new TaskConfig()
-                .setJob(new JobKey(role, env, jobName))
-                .setJobName(jobName)
-                .setEnvironment(env)
-                .setOwner(new Identity(role, role))
-                .setIsService(true)
-                .setNumCpus(1.0)
-                .setRamMb(1024)
-                .setDiskMb(1024)
-                .setPriority(1)
-                .setMaxTaskFailures(-1)
-                .setProduction(true)
-                .setConstraints(ImmutableSet.of(
-                    new Constraint(
-                        "name",
-                        TaskConstraint.value(
-                            new ValueConstraint(false, ImmutableSet.of("value"))))))
-                .setRequestedPorts(ImmutableSet.of("http"))
-                .setTaskLinks(ImmutableMap.of("http", "link"))
-                .setContactEmail("foo@bar.com")
-                .setMetadata(ImmutableSet.of(new Metadata("key", "value")))
-                .setExecutorConfig(new ExecutorConfig("name", "config")))));
-  }
-
-  private static IScheduledTask makeTask(String id) {
-    return makeTask(id, "role-" + id, "env-" + id, "job-" + id);
+    assertQueryResults(query, ImmutableSet.copyOf(tasks));
+  }
+
+  private void assertQueryResults(Query.Builder query, Set<IScheduledTask> tasks) {
+    assertEquals(tasks, fetchTasks(query));
+  }
+
+  private static IScheduledTask createTask(String id) {
+    return makeTask(id, JobKeys.from("role-" + id, "env-" + id, "job-" + id));
+  }
+
+  private static IScheduledTask setContainer(IScheduledTask task, Container container) {
+    ScheduledTask builder = task.newBuilder();
+    builder.getAssignedTask().getTask().setContainer(container);
+    return IScheduledTask.build(builder);
   }
 }

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/storage/testing/StorageEntityUtil.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/storage/testing/StorageEntityUtil.java b/src/test/java/org/apache/aurora/scheduler/storage/testing/StorageEntityUtil.java
index b26ddd3..0bde4d8 100644
--- a/src/test/java/org/apache/aurora/scheduler/storage/testing/StorageEntityUtil.java
+++ b/src/test/java/org/apache/aurora/scheduler/storage/testing/StorageEntityUtil.java
@@ -19,11 +19,13 @@ import java.util.Collection;
 import java.util.Map;
 import java.util.Set;
 
+import com.google.common.base.Defaults;
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableSet;
 import com.google.gson.internal.Primitives;
 
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
 
 /**
@@ -49,20 +51,29 @@ public final class StorageEntityUtil {
         assertFullyPopulated(name + " key", entry.getKey(), ignoredFields);
         assertFullyPopulated(name + "[" + entry.getKey() + "]", entry.getValue(), ignoredFields);
       }
-    } else if (!Primitives.isPrimitive(object.getClass())
-        && !Primitives.isWrapperType(object.getClass())) {
-
+    } else if (!(object instanceof String) && !(object instanceof Enum)) {
       for (Field field : object.getClass().getDeclaredFields()) {
         if (!Modifier.isStatic(field.getModifiers())) {
           try {
             field.setAccessible(true);
             String fullName = name + "." + field.getName();
-            Object value = field.get(object);
-            if (!ignoredFields.contains(field)) {
-              assertNotNull(fullName + " is null", value);
+            Object fieldValue = field.get(object);
+            boolean mustBeSet = !ignoredFields.contains(field);
+            if (mustBeSet) {
+              assertNotNull(fullName + " is null", fieldValue);
             }
-            if (value != null) {
-              assertFullyPopulated(fullName, value, ignoredFields);
+            if (fieldValue != null) {
+              if (Primitives.isWrapperType(fieldValue.getClass())) {
+                // Special-case the mutable hash code field.
+                if (mustBeSet && !fullName.endsWith("cachedHashCode")) {
+                  assertNotEquals(
+                      "Primitive value must not be default: " + fullName,
+                      Defaults.defaultValue(Primitives.unwrap(fieldValue.getClass())),
+                      fieldValue);
+                }
+              } else {
+                assertFullyPopulated(fullName, fieldValue, ignoredFields);
+              }
             }
           } catch (IllegalAccessException e) {
             throw Throwables.propagate(e);

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/updater/InstanceUpdaterTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/updater/InstanceUpdaterTest.java b/src/test/java/org/apache/aurora/scheduler/updater/InstanceUpdaterTest.java
index 3f1f72b..1128303 100644
--- a/src/test/java/org/apache/aurora/scheduler/updater/InstanceUpdaterTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/updater/InstanceUpdaterTest.java
@@ -13,16 +13,22 @@
  */
 package org.apache.aurora.scheduler.updater;
 
+import java.util.List;
+import java.util.Objects;
+
 import com.google.common.base.Optional;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
 import com.twitter.common.quantity.Amount;
 import com.twitter.common.quantity.Time;
 import com.twitter.common.util.testing.FakeClock;
 
+import org.apache.aurora.gen.AssignedTask;
 import org.apache.aurora.gen.ScheduleStatus;
 import org.apache.aurora.gen.ScheduledTask;
 import org.apache.aurora.gen.TaskConfig;
 import org.apache.aurora.gen.TaskEvent;
+import org.apache.aurora.scheduler.base.Tasks;
 import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
 import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
 import org.junit.Test;
@@ -263,4 +269,33 @@ public class InstanceUpdaterTest {
     f.advanceTime(MIN_RUNNING_TIME);
     f.evaluateCurrentState(SUCCEEDED);
   }
+
+  static final class TaskUtil {
+    private final FakeClock clock;
+
+    TaskUtil(FakeClock clock) {
+      this.clock = Objects.requireNonNull(clock);
+    }
+
+    IScheduledTask makeTask(ITaskConfig config, ScheduleStatus status) {
+      List<TaskEvent> events = Lists.newArrayList();
+      if (status != PENDING) {
+        events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(PENDING));
+      }
+      if (Tasks.isTerminated(status) || status == KILLING) {
+        events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(ASSIGNED));
+        events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(RUNNING));
+      }
+
+      events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(status));
+
+      return IScheduledTask.build(
+          new ScheduledTask()
+              .setStatus(status)
+              .setTaskEvents(ImmutableList.copyOf(events))
+              .setAssignedTask(
+                  new AssignedTask()
+                      .setTask(config.newBuilder())));
+    }
+  }
 }

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/updater/JobUpdaterIT.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/updater/JobUpdaterIT.java b/src/test/java/org/apache/aurora/scheduler/updater/JobUpdaterIT.java
index dd4c940..6be0efa 100644
--- a/src/test/java/org/apache/aurora/scheduler/updater/JobUpdaterIT.java
+++ b/src/test/java/org/apache/aurora/scheduler/updater/JobUpdaterIT.java
@@ -43,10 +43,7 @@ import com.twitter.common.testing.easymock.EasyMockTest;
 import com.twitter.common.util.Clock;
 import com.twitter.common.util.TruncatedBinaryBackoff;
 
-import org.apache.aurora.gen.ExecutorConfig;
-import org.apache.aurora.gen.Identity;
 import org.apache.aurora.gen.InstanceTaskConfig;
-import org.apache.aurora.gen.JobKey;
 import org.apache.aurora.gen.JobUpdate;
 import org.apache.aurora.gen.JobUpdateAction;
 import org.apache.aurora.gen.JobUpdateEvent;
@@ -67,6 +64,7 @@ import org.apache.aurora.scheduler.async.RescheduleCalculator;
 import org.apache.aurora.scheduler.async.RescheduleCalculator.RescheduleCalculatorImpl;
 import org.apache.aurora.scheduler.base.JobKeys;
 import org.apache.aurora.scheduler.base.Query;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
 import org.apache.aurora.scheduler.base.Tasks;
 import org.apache.aurora.scheduler.events.EventSink;
 import org.apache.aurora.scheduler.events.PubsubEvent;
@@ -146,8 +144,8 @@ public class JobUpdaterIT extends EasyMockTest {
   private static final Amount<Long, Time> FLAPPING_THRESHOLD = Amount.of(1L, Time.MILLISECONDS);
   private static final Amount<Long, Time> ONE_DAY = Amount.of(1L, Time.DAYS);
   private static final ITaskConfig OLD_CONFIG =
-      ITaskConfig.build(makeTaskConfig().setExecutorConfig(new ExecutorConfig().setName("new")));
-  private static final ITaskConfig NEW_CONFIG = ITaskConfig.build(makeTaskConfig());
+      setExecutorData(TaskTestUtil.makeConfig(JOB), "olddata");
+  private static final ITaskConfig NEW_CONFIG = setExecutorData(OLD_CONFIG, "newdata");
   private static final long PULSE_TIMEOUT_MS = 10000;
 
   private FakeScheduledExecutor clock;
@@ -159,6 +157,12 @@ public class JobUpdaterIT extends EasyMockTest {
   private StateManager stateManager;
   private JobUpdateEventSubscriber subscriber;
 
+  private static ITaskConfig setExecutorData(ITaskConfig task, String executorData) {
+    TaskConfig builder = task.newBuilder();
+    builder.getExecutorConfig().setData(executorData);
+    return ITaskConfig.build(builder);
+  }
+
   @Before
   public void setUp() {
     // Avoid console spam due to stats registered multiple times.
@@ -1327,15 +1331,4 @@ public class JobUpdaterIT extends EasyMockTest {
         .setInstances(ImmutableSet.of(new Range(start, end)))
         .setTask(config.newBuilder()));
   }
-
-  private static TaskConfig makeTaskConfig() {
-    return new TaskConfig()
-        .setJob(new JobKey(JOB.newBuilder()))
-        .setJobName(JOB.getName())
-        .setEnvironment(JOB.getEnvironment())
-        .setOwner(new Identity(JOB.getRole(), "user"))
-        .setIsService(true)
-        .setExecutorConfig(new ExecutorConfig().setName("old"))
-        .setNumCpus(1);
-  }
 }

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/updater/TaskUtil.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/updater/TaskUtil.java b/src/test/java/org/apache/aurora/scheduler/updater/TaskUtil.java
deleted file mode 100644
index 0e67f91..0000000
--- a/src/test/java/org/apache/aurora/scheduler/updater/TaskUtil.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/**
- * 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 org.apache.aurora.scheduler.updater;
-
-import java.util.List;
-import java.util.Objects;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
-import com.twitter.common.util.testing.FakeClock;
-
-import org.apache.aurora.gen.AssignedTask;
-import org.apache.aurora.gen.ScheduleStatus;
-import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskEvent;
-import org.apache.aurora.scheduler.base.Tasks;
-import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
-import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
-
-import static org.apache.aurora.gen.ScheduleStatus.ASSIGNED;
-import static org.apache.aurora.gen.ScheduleStatus.KILLING;
-import static org.apache.aurora.gen.ScheduleStatus.PENDING;
-import static org.apache.aurora.gen.ScheduleStatus.RUNNING;
-
-final class TaskUtil {
-
-  private final FakeClock clock;
-
-  TaskUtil(FakeClock clock) {
-    this.clock = Objects.requireNonNull(clock);
-  }
-
-  IScheduledTask makeTask(ITaskConfig config, ScheduleStatus status) {
-    List<TaskEvent> events = Lists.newArrayList();
-    if (status != PENDING) {
-      events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(PENDING));
-    }
-    if (Tasks.isTerminated(status) || status == KILLING) {
-      events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(ASSIGNED));
-      events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(RUNNING));
-    }
-
-    events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(status));
-
-    return IScheduledTask.build(
-        new ScheduledTask()
-            .setStatus(status)
-            .setTaskEvents(ImmutableList.copyOf(events))
-            .setAssignedTask(
-                new AssignedTask()
-                    .setTask(config.newBuilder())));
-  }
-}


[3/3] aurora git commit: Require non-default primitive values in StorageEntityUtil.

Posted by wf...@apache.org.
Require non-default primitive values in StorageEntityUtil.

Reviewed at https://reviews.apache.org/r/33200/


Project: http://git-wip-us.apache.org/repos/asf/aurora/repo
Commit: http://git-wip-us.apache.org/repos/asf/aurora/commit/449a835e
Tree: http://git-wip-us.apache.org/repos/asf/aurora/tree/449a835e
Diff: http://git-wip-us.apache.org/repos/asf/aurora/diff/449a835e

Branch: refs/heads/master
Commit: 449a835e9a446987cd9033345eb580030ed35cfa
Parents: 3380572
Author: Bill Farner <wf...@apache.org>
Authored: Tue Apr 21 11:51:51 2015 -0700
Committer: Bill Farner <wf...@apache.org>
Committed: Tue Apr 21 11:51:51 2015 -0700

----------------------------------------------------------------------
 .../java/org/apache/aurora/benchmark/Tasks.java |   39 +-
 .../aurora/scheduler/base/TaskTestUtil.java     |  113 ++
 .../scheduler/async/TaskSchedulerImplTest.java  |   25 +-
 .../scheduler/async/TaskSchedulerTest.java      |   93 +-
 .../apache/aurora/scheduler/base/JobsTest.java  |    5 +-
 .../aurora/scheduler/base/TaskTestUtil.java     |   66 --
 .../apache/aurora/scheduler/base/TasksTest.java |   21 +-
 .../scheduler/state/StateManagerImplTest.java   |  135 +--
 .../scheduler/stats/ResourceCounterTest.java    |   21 +-
 .../scheduler/storage/StorageBackfillTest.java  |  140 +--
 .../scheduler/storage/backup/RecoveryTest.java  |   25 +-
 .../storage/db/DBJobUpdateStoreTest.java        | 1076 ------------------
 .../storage/db/DbJobUpdateStoreTest.java        | 1061 +++++++++++++++++
 .../scheduler/storage/mem/MemTaskStoreTest.java |  391 ++++---
 .../storage/testing/StorageEntityUtil.java      |   27 +-
 .../scheduler/updater/InstanceUpdaterTest.java  |   35 +
 .../aurora/scheduler/updater/JobUpdaterIT.java  |   25 +-
 .../aurora/scheduler/updater/TaskUtil.java      |   64 --
 18 files changed, 1665 insertions(+), 1697 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/jmh/java/org/apache/aurora/benchmark/Tasks.java
----------------------------------------------------------------------
diff --git a/src/jmh/java/org/apache/aurora/benchmark/Tasks.java b/src/jmh/java/org/apache/aurora/benchmark/Tasks.java
index 23827ab..b4da057 100644
--- a/src/jmh/java/org/apache/aurora/benchmark/Tasks.java
+++ b/src/jmh/java/org/apache/aurora/benchmark/Tasks.java
@@ -20,17 +20,16 @@ import com.google.common.collect.Lists;
 import com.twitter.common.quantity.Amount;
 import com.twitter.common.quantity.Data;
 
-import org.apache.aurora.gen.AssignedTask;
 import org.apache.aurora.gen.Constraint;
-import org.apache.aurora.gen.Identity;
 import org.apache.aurora.gen.JobKey;
 import org.apache.aurora.gen.LimitConstraint;
 import org.apache.aurora.gen.ScheduleStatus;
 import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskConfig;
 import org.apache.aurora.gen.TaskConstraint;
 import org.apache.aurora.gen.TaskEvent;
 import org.apache.aurora.gen.ValueConstraint;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
+import org.apache.aurora.scheduler.storage.entities.IJobKey;
 import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
 
 /**
@@ -134,25 +133,23 @@ final class Tasks {
         String taskId =
             jobKey.getRole() + "-" + jobKey.getEnvironment() + "-" + i + "-" + (uuidStart + i);
 
-        tasks.add(IScheduledTask.build(new ScheduledTask()
-            .setTaskEvents(Lists.newArrayList(new TaskEvent(0, ScheduleStatus.PENDING)))
+        ScheduledTask builder = TaskTestUtil.makeTask(taskId, IJobKey.build(jobKey))
+            .newBuilder()
             .setStatus(scheduleStatus)
-            .setAssignedTask(new AssignedTask()
-                .setInstanceId(i)
-                .setTaskId(taskId)
-                .setTask(new TaskConfig()
-                    .setConstraints(constraints.build())
-                    .setNumCpus(cpu)
-                    .setRamMb(ram.as(Data.MB))
-                    .setDiskMb(disk.as(Data.MB))
-                    .setProduction(isProduction)
-                    .setRequestedPorts(ImmutableSet.<String>of())
-                    .setJob(jobKey)
-                    .setJobName(jobKey.getName())
-                    .setEnvironment(jobKey.getEnvironment())
-                    .setOwner(new Identity()
-                        .setRole(jobKey.getRole())
-                        .setUser(String.format(USER_FORMAT, taskId)))))));
+            .setTaskEvents(Lists.newArrayList(
+                new TaskEvent(0, ScheduleStatus.PENDING),
+                new TaskEvent(1, scheduleStatus)));
+        builder.getAssignedTask()
+            .setInstanceId(i)
+            .setTaskId(taskId);
+        builder.getAssignedTask().getTask()
+            .setConstraints(constraints.build())
+            .setNumCpus(cpu)
+            .setRamMb(ram.as(Data.MB))
+            .setDiskMb(disk.as(Data.MB))
+            .setProduction(isProduction)
+            .setRequestedPorts(ImmutableSet.<String>of());
+        tasks.add(IScheduledTask.build(builder));
       }
 
       return tasks.build();

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/main/java/org/apache/aurora/scheduler/base/TaskTestUtil.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/aurora/scheduler/base/TaskTestUtil.java b/src/main/java/org/apache/aurora/scheduler/base/TaskTestUtil.java
new file mode 100644
index 0000000..2f42851
--- /dev/null
+++ b/src/main/java/org/apache/aurora/scheduler/base/TaskTestUtil.java
@@ -0,0 +1,113 @@
+/**
+ * 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 org.apache.aurora.scheduler.base;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+
+import org.apache.aurora.gen.AssignedTask;
+import org.apache.aurora.gen.Constraint;
+import org.apache.aurora.gen.Container;
+import org.apache.aurora.gen.DockerContainer;
+import org.apache.aurora.gen.ExecutorConfig;
+import org.apache.aurora.gen.Identity;
+import org.apache.aurora.gen.LimitConstraint;
+import org.apache.aurora.gen.Metadata;
+import org.apache.aurora.gen.ScheduleStatus;
+import org.apache.aurora.gen.ScheduledTask;
+import org.apache.aurora.gen.TaskConfig;
+import org.apache.aurora.gen.TaskConstraint;
+import org.apache.aurora.gen.TaskEvent;
+import org.apache.aurora.gen.ValueConstraint;
+import org.apache.aurora.scheduler.storage.entities.IJobKey;
+import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
+import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
+
+/**
+ * Convenience methods for working with tasks.
+ * <p>
+ * TODO(wfarner): This lives in under src/main only so benchmarks can access it.  Reconsider the
+ * project layout so this is not necessary.
+ */
+public final class TaskTestUtil {
+
+  public static final IJobKey JOB = JobKeys.from("role", "env", "job");
+
+  private TaskTestUtil() {
+    // Utility class.
+  }
+
+  public static ITaskConfig makeConfig(IJobKey job) {
+    return ITaskConfig.build(new TaskConfig()
+        .setJob(job.newBuilder())
+        .setJobName(job.getName())
+        .setEnvironment(job.getEnvironment())
+        .setOwner(new Identity(job.getRole(), job.getRole() + "-user"))
+        .setIsService(true)
+        .setNumCpus(1.0)
+        .setRamMb(1024)
+        .setDiskMb(1024)
+        .setPriority(1)
+        .setMaxTaskFailures(-1)
+        .setProduction(true)
+        .setConstraints(ImmutableSet.of(
+            new Constraint(
+                "valueConstraint",
+                TaskConstraint.value(
+                    new ValueConstraint(false, ImmutableSet.of("value1", "value2")))),
+            new Constraint(
+                "limitConstraint",
+                TaskConstraint.limit(new LimitConstraint(5)))))
+        .setRequestedPorts(ImmutableSet.of("http"))
+        .setTaskLinks(ImmutableMap.of("http", "link", "admin", "otherLink"))
+        .setContactEmail("foo@bar.com")
+        .setMetadata(ImmutableSet.of(new Metadata("key", "value")))
+        .setExecutorConfig(new ExecutorConfig("name", "config"))
+        .setContainer(Container.docker(new DockerContainer("imagename"))));
+  }
+
+  public static IScheduledTask makeTask(String id, IJobKey job) {
+    return IScheduledTask.build(new ScheduledTask()
+        .setStatus(ScheduleStatus.PENDING)
+        .setTaskEvents(ImmutableList.of(
+            new TaskEvent(100L, ScheduleStatus.PENDING)
+                .setMessage("message")
+                .setScheduler("scheduler"),
+            new TaskEvent(101L, ScheduleStatus.ASSIGNED)
+                .setMessage("message")
+                .setScheduler("scheduler2")))
+        .setAncestorId("ancestor")
+        .setFailureCount(3)
+        .setAssignedTask(new AssignedTask()
+            .setInstanceId(2)
+            .setTaskId(id)
+            .setAssignedPorts(ImmutableMap.of("http", 1000))
+            .setTask(makeConfig(job).newBuilder())));
+  }
+
+  public static IScheduledTask addStateTransition(
+      IScheduledTask task,
+      ScheduleStatus status,
+      long timestamp) {
+
+    ScheduledTask builder = task.newBuilder();
+    builder.setStatus(status);
+    builder.addToTaskEvents(new TaskEvent()
+        .setTimestamp(timestamp)
+        .setStatus(status)
+        .setScheduler("scheduler"));
+    return IScheduledTask.build(builder);
+  }
+}

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerImplTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerImplTest.java b/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerImplTest.java
index d879d33..bd1aaa1 100644
--- a/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerImplTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerImplTest.java
@@ -20,24 +20,21 @@ import com.google.inject.AbstractModule;
 import com.google.inject.Guice;
 import com.google.inject.Injector;
 import com.google.inject.TypeLiteral;
-
 import com.twitter.common.stats.StatsProvider;
 import com.twitter.common.testing.easymock.EasyMockTest;
 import com.twitter.common.util.Clock;
 
-import org.apache.aurora.gen.AssignedTask;
 import org.apache.aurora.gen.HostAttributes;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.JobKey;
 import org.apache.aurora.gen.MaintenanceMode;
 import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskConfig;
 import org.apache.aurora.scheduler.HostOffer;
 import org.apache.aurora.scheduler.async.TaskScheduler.TaskSchedulerImpl;
 import org.apache.aurora.scheduler.async.preemptor.BiCache;
 import org.apache.aurora.scheduler.async.preemptor.Preemptor;
+import org.apache.aurora.scheduler.base.JobKeys;
 import org.apache.aurora.scheduler.base.Query;
 import org.apache.aurora.scheduler.base.TaskGroupKey;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
 import org.apache.aurora.scheduler.base.Tasks;
 import org.apache.aurora.scheduler.events.EventSink;
 import org.apache.aurora.scheduler.events.PubsubEvent.TaskStateChange;
@@ -75,8 +72,10 @@ import static org.junit.Assert.assertTrue;
 
 public class TaskSchedulerImplTest extends EasyMockTest {
 
-  private static final IScheduledTask TASK_A = makeTask("a");
-  private static final IScheduledTask TASK_B = makeTask("b");
+  private static final IScheduledTask TASK_A =
+      TaskTestUtil.makeTask("a", JobKeys.from("a", "a", "a"));
+  private static final IScheduledTask TASK_B =
+      TaskTestUtil.makeTask("b", JobKeys.from("b", "b", "b"));
   private static final HostOffer OFFER = new HostOffer(
       Offers.makeOffer("OFFER_A", "HOST_A"),
       IHostAttributes.build(new HostAttributes().setMode(MaintenanceMode.NONE)));
@@ -276,18 +275,6 @@ public class TaskSchedulerImplTest extends EasyMockTest {
     assignAndAssert(Result.SUCCESS, GROUP_A, OFFER, assignment);
   }
 
-  private static IScheduledTask makeTask(String taskId) {
-    return IScheduledTask.build(new ScheduledTask()
-        .setAssignedTask(new AssignedTask()
-            .setInstanceId(0)
-            .setTaskId(taskId)
-            .setTask(new TaskConfig()
-                .setJob(new JobKey("role-" + taskId, "env-" + taskId, "job-" + taskId))
-                .setJobName("job-" + taskId)
-                .setOwner(new Identity().setRole("role-" + taskId).setUser("user-" + taskId))
-                .setEnvironment("env-" + taskId))));
-  }
-
   private static class AssignmentCapture {
     public Capture<Function<HostOffer, Assignment>> assigner = createCapture();
     public Capture<TaskGroupKey> groupKey = createCapture();

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerTest.java b/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerTest.java
index 798ff6e..9035484 100644
--- a/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerTest.java
@@ -17,6 +17,8 @@ import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 
+import javax.annotation.Nullable;
+
 import com.google.common.base.Function;
 import com.google.common.base.Optional;
 import com.google.common.collect.ImmutableList;
@@ -28,11 +30,8 @@ import com.twitter.common.quantity.Time;
 import com.twitter.common.testing.easymock.EasyMockTest;
 import com.twitter.common.util.BackoffStrategy;
 
-import org.apache.aurora.gen.AssignedTask;
 import org.apache.aurora.gen.Attribute;
 import org.apache.aurora.gen.HostAttributes;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.JobKey;
 import org.apache.aurora.gen.MaintenanceMode;
 import org.apache.aurora.gen.ScheduleStatus;
 import org.apache.aurora.gen.ScheduledTask;
@@ -43,8 +42,10 @@ import org.apache.aurora.scheduler.async.OfferManager.OfferReturnDelay;
 import org.apache.aurora.scheduler.async.TaskScheduler.TaskSchedulerImpl;
 import org.apache.aurora.scheduler.async.preemptor.BiCache;
 import org.apache.aurora.scheduler.async.preemptor.Preemptor;
+import org.apache.aurora.scheduler.base.JobKeys;
 import org.apache.aurora.scheduler.base.Query;
 import org.apache.aurora.scheduler.base.TaskGroupKey;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
 import org.apache.aurora.scheduler.base.Tasks;
 import org.apache.aurora.scheduler.events.PubsubEvent;
 import org.apache.aurora.scheduler.events.PubsubEvent.TaskStateChange;
@@ -61,6 +62,7 @@ import org.apache.aurora.scheduler.storage.Storage.MutableStoreProvider;
 import org.apache.aurora.scheduler.storage.Storage.MutateWork;
 import org.apache.aurora.scheduler.storage.Storage.StorageException;
 import org.apache.aurora.scheduler.storage.TaskStore;
+import org.apache.aurora.scheduler.storage.entities.IAssignedTask;
 import org.apache.aurora.scheduler.storage.entities.IHostAttributes;
 import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
 import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
@@ -85,6 +87,7 @@ import static org.apache.aurora.gen.ScheduleStatus.KILLED;
 import static org.apache.aurora.gen.ScheduleStatus.LOST;
 import static org.apache.aurora.gen.ScheduleStatus.PENDING;
 import static org.apache.aurora.gen.ScheduleStatus.RUNNING;
+import static org.apache.aurora.scheduler.base.TaskTestUtil.makeTask;
 import static org.apache.aurora.scheduler.filter.AttributeAggregate.EMPTY;
 import static org.apache.mesos.Protos.Offer;
 import static org.easymock.EasyMock.capture;
@@ -221,37 +224,33 @@ public class TaskSchedulerTest extends EasyMockTest {
   public void testNoOffers() {
     Capture<Runnable> timeoutCapture = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
     expectTaskGroupBackoff(FIRST_SCHEDULE_DELAY_MS, 10);
-    IScheduledTask task = makeTask("a");
-    expectPreemptorCall(task);
+    IScheduledTask task = createTask("a");
+    expectPreemptorCall(task.getAssignedTask());
     expectReservationCheck(task);
 
     replayAndCreateScheduler();
 
-    changeState(makeTask("a"), INIT, PENDING);
+    changeState(task, INIT, PENDING);
     timeoutCapture.getValue().run();
   }
 
-  private IScheduledTask makeTask(String taskId) {
-    return IScheduledTask.build(new ScheduledTask()
-        .setAssignedTask(new AssignedTask()
-            .setInstanceId(0)
-            .setTaskId(taskId)
-            .setTask(new TaskConfig()
-                .setJob(new JobKey("role-" + taskId, "env-" + taskId, "job-" + taskId))
-                .setJobName("job-" + taskId)
-                .setOwner(new Identity().setRole("role-" + taskId).setUser("user-" + taskId))
-                .setEnvironment("env-" + taskId))));
+  private IScheduledTask createTask(String taskId) {
+    return createTask(taskId, null);
+  }
+
+  private IScheduledTask createTask(String taskId, @Nullable ScheduleStatus status) {
+    return setStatus(makeTask(taskId, TaskTestUtil.JOB), status);
   }
 
-  private IScheduledTask makeTask(String taskId, ScheduleStatus status) {
-    return IScheduledTask.build(makeTask(taskId).newBuilder().setStatus(status));
+  private IScheduledTask setStatus(IScheduledTask task, @Nullable ScheduleStatus status) {
+    return IScheduledTask.build(task.newBuilder().setStatus(status));
   }
 
   @Test
   public void testLoadFromStorage() {
-    final IScheduledTask a = makeTask("a", KILLED);
-    final IScheduledTask b = makeTask("b", PENDING);
-    final IScheduledTask c = makeTask("c", RUNNING);
+    final IScheduledTask a = createTask("a", KILLED);
+    final IScheduledTask b = createTask("b", PENDING);
+    final IScheduledTask c = createTask("c", RUNNING);
 
     expect(rescheduleCalculator.getStartupScheduleDelayMs(b)).andReturn(10L);
     expectTaskRetryIn(10);
@@ -276,7 +275,7 @@ public class TaskSchedulerTest extends EasyMockTest {
 
     replayAndCreateScheduler();
 
-    taskGroups.taskChangedState(TaskStateChange.transition(makeTask("a", PENDING), INIT));
+    taskGroups.taskChangedState(TaskStateChange.transition(createTask("a", PENDING), INIT));
     timeoutCapture.getValue().run();
   }
 
@@ -306,40 +305,40 @@ public class TaskSchedulerTest extends EasyMockTest {
     expectAnyMaintenanceCalls();
     expectOfferDeclineIn(10);
 
-    IScheduledTask task = makeTask("a", PENDING);
-    TaskInfo mesosTask = makeTaskInfo(task);
+    IScheduledTask taskA = createTask("a", PENDING);
+    TaskInfo mesosTask = makeTaskInfo(taskA);
 
     Capture<Runnable> timeoutCapture = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
     expectNoReservation(SLAVE_A).times(2);
-    expectReservationCheck(task);
-    expectMaybeAssign(OFFER_A, task, EMPTY).andReturn(Assignment.failure());
-    expectPreemptorCall(task);
+    expectReservationCheck(taskA);
+    expectMaybeAssign(OFFER_A, taskA, EMPTY).andReturn(Assignment.failure());
+    expectPreemptorCall(taskA.getAssignedTask());
 
     Capture<Runnable> timeoutCapture2 = expectTaskGroupBackoff(FIRST_SCHEDULE_DELAY_MS, 10);
-    expectMaybeAssign(OFFER_A, task, EMPTY).andReturn(Assignment.success(mesosTask));
+    expectMaybeAssign(OFFER_A, taskA, EMPTY).andReturn(Assignment.success(mesosTask));
     driver.launchTask(OFFER_A.getOffer().getId(), mesosTask);
 
     Capture<Runnable> timeoutCapture3 = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
     expectTaskGroupBackoff(FIRST_SCHEDULE_DELAY_MS, 10);
-    IScheduledTask taskB = makeTask("b");
+    IScheduledTask taskB = createTask("b");
     expectReservationCheck(taskB);
-    expectPreemptorCall(taskB);
+    expectPreemptorCall(taskB.getAssignedTask());
 
     replayAndCreateScheduler();
 
     offerManager.addOffer(OFFER_A);
-    changeState(task, INIT, PENDING);
+    changeState(taskA, INIT, PENDING);
     timeoutCapture.getValue().run();
     timeoutCapture2.getValue().run();
 
     // Ensure the offer was consumed.
-    changeState(makeTask("b"), INIT, PENDING);
+    changeState(taskB, INIT, PENDING);
     timeoutCapture3.getValue().run();
   }
 
   @Test
   public void testDriverNotReady() {
-    IScheduledTask task = makeTask("a", PENDING);
+    IScheduledTask task = createTask("a", PENDING);
     TaskInfo mesosTask = TaskInfo.newBuilder()
         .setName(Tasks.id(task))
         .setTaskId(TaskID.newBuilder().setValue(Tasks.id(task)))
@@ -370,7 +369,7 @@ public class TaskSchedulerTest extends EasyMockTest {
 
   @Test
   public void testStorageException() {
-    IScheduledTask task = makeTask("a", PENDING);
+    IScheduledTask task = createTask("a", PENDING);
     TaskInfo mesosTask = TaskInfo.newBuilder()
         .setName(Tasks.id(task))
         .setTaskId(TaskID.newBuilder().setValue(Tasks.id(task)))
@@ -398,7 +397,7 @@ public class TaskSchedulerTest extends EasyMockTest {
 
   @Test
   public void testExpiration() {
-    IScheduledTask task = makeTask("a", PENDING);
+    IScheduledTask task = createTask("a", PENDING);
 
     Capture<Runnable> timeoutCapture = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
     Capture<Runnable> offerExpirationCapture = expectOfferDeclineIn(10);
@@ -407,10 +406,10 @@ public class TaskSchedulerTest extends EasyMockTest {
     expectReservationCheck(task).times(2);
     expectMaybeAssign(OFFER_A, task, EMPTY).andReturn(Assignment.failure());
     Capture<Runnable> timeoutCapture2 = expectTaskGroupBackoff(FIRST_SCHEDULE_DELAY_MS, 10);
-    expectPreemptorCall(task);
+    expectPreemptorCall(task.getAssignedTask());
     driver.declineOffer(OFFER_A.getOffer().getId());
     expectTaskGroupBackoff(10, 20);
-    expectPreemptorCall(task);
+    expectPreemptorCall(task.getAssignedTask());
 
     replayAndCreateScheduler();
 
@@ -465,14 +464,14 @@ public class TaskSchedulerTest extends EasyMockTest {
     expectOffer();
     expectOffer();
 
-    IScheduledTask taskA = makeTask("A", PENDING);
+    IScheduledTask taskA = createTask("A", PENDING);
     TaskInfo mesosTaskA = makeTaskInfo(taskA);
     expectNoReservation(SLAVE_A);
     expectMaybeAssign(OFFER_A, taskA, EMPTY).andReturn(Assignment.success(mesosTaskA));
     driver.launchTask(OFFER_A.getOffer().getId(), mesosTaskA);
     Capture<Runnable> captureA = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
 
-    IScheduledTask taskB = makeTask("B", PENDING);
+    IScheduledTask taskB = createTask("B", PENDING);
     TaskInfo mesosTaskB = makeTaskInfo(taskB);
     expectNoReservation(SLAVE_B);
     expectMaybeAssign(OFFER_B, taskB, EMPTY).andReturn(Assignment.success(mesosTaskB));
@@ -499,14 +498,14 @@ public class TaskSchedulerTest extends EasyMockTest {
     expectOffer();
     expectOffer();
 
-    IScheduledTask taskA = makeTask("A", PENDING);
+    IScheduledTask taskA = createTask("A", PENDING);
     TaskInfo mesosTaskA = makeTaskInfo(taskA);
     expectNoReservation(SLAVE_B);
     expectMaybeAssign(OFFER_B, taskA, EMPTY).andReturn(Assignment.success(mesosTaskA));
     driver.launchTask(OFFER_B.getOffer().getId(), mesosTaskA);
     Capture<Runnable> captureA = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
 
-    IScheduledTask taskB = makeTask("B", PENDING);
+    IScheduledTask taskB = createTask("B", PENDING);
     TaskInfo mesosTaskB = makeTaskInfo(taskB);
     HostOffer updatedOfferC = new HostOffer(
         OFFER_C.getOffer(),
@@ -554,7 +553,7 @@ public class TaskSchedulerTest extends EasyMockTest {
 
     expectAnyMaintenanceCalls();
 
-    IScheduledTask jobA0 = makeTask("a0", PENDING);
+    IScheduledTask jobA0 = setStatus(makeTask("a0", JobKeys.from("a", "b", "c")), PENDING);
 
     ScheduledTask jobA1Builder = jobA0.newBuilder();
     jobA1Builder.getAssignedTask().setTaskId("a1");
@@ -566,7 +565,7 @@ public class TaskSchedulerTest extends EasyMockTest {
     jobA2Builder.getAssignedTask().setInstanceId(2);
     IScheduledTask jobA2 = IScheduledTask.build(jobA2Builder);
 
-    IScheduledTask jobB0 = makeTask("b0", PENDING);
+    IScheduledTask jobB0 = setStatus(makeTask("b0", JobKeys.from("d", "e", "f")), PENDING);
 
     expectNoReservation(SLAVE_A);
     expectNoReservation(SLAVE_B);
@@ -607,14 +606,14 @@ public class TaskSchedulerTest extends EasyMockTest {
     expectAnyMaintenanceCalls();
     expectOfferDeclineIn(10);
 
-    final IScheduledTask task = makeTask("a", PENDING);
+    final IScheduledTask task = createTask("a", PENDING);
 
     Capture<Runnable> timeoutCapture = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
     expectNoReservation(SLAVE_A);
     expectMaybeAssign(OFFER_A, task, EMPTY).andReturn(Assignment.failure());
     expectTaskGroupBackoff(FIRST_SCHEDULE_DELAY_MS, 20);
     expectReservationCheck(task);
-    expectPreemptorCall(task);
+    expectPreemptorCall(task.getAssignedTask());
 
     replayAndCreateScheduler();
 
@@ -662,9 +661,9 @@ public class TaskSchedulerTest extends EasyMockTest {
             .setMode(mode)));
   }
 
-  private void expectPreemptorCall(IScheduledTask task) {
+  private void expectPreemptorCall(IAssignedTask task) {
     expect(preemptor.attemptPreemptionFor(
-        eq(task.getAssignedTask()),
+        eq(task),
         eq(EMPTY),
         EasyMock.<MutableStoreProvider>anyObject())).andReturn(Optional.<String>absent());
   }

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/base/JobsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/base/JobsTest.java b/src/test/java/org/apache/aurora/scheduler/base/JobsTest.java
index a170fb6..986fd01 100644
--- a/src/test/java/org/apache/aurora/scheduler/base/JobsTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/base/JobsTest.java
@@ -25,12 +25,11 @@ import org.apache.aurora.scheduler.storage.entities.IJobStats;
 import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
 import org.junit.Test;
 
+import static org.apache.aurora.scheduler.base.TaskTestUtil.addStateTransition;
 import static org.apache.aurora.scheduler.base.TaskTestUtil.makeTask;
-import static org.apache.aurora.scheduler.base.TaskTestUtil.makeTaskEvents;
 import static org.junit.Assert.assertEquals;
 
 public class JobsTest {
-
   @Test
   public void testGetJobStats() {
     ImmutableList<IScheduledTask> tasks =
@@ -39,7 +38,7 @@ public class JobsTest {
             .transform(new Function<ScheduleStatus, IScheduledTask>() {
               @Override
               public IScheduledTask apply(ScheduleStatus status) {
-                return makeTask(status, makeTaskEvents(100, status));
+                return addStateTransition(makeTask("id", TaskTestUtil.JOB), status, 100L);
               }
             }).toList();
 

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/base/TaskTestUtil.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/base/TaskTestUtil.java b/src/test/java/org/apache/aurora/scheduler/base/TaskTestUtil.java
deleted file mode 100644
index b8b9c1b..0000000
--- a/src/test/java/org/apache/aurora/scheduler/base/TaskTestUtil.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/**
- * 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 org.apache.aurora.scheduler.base;
-
-import java.util.List;
-
-import com.google.common.collect.ImmutableList;
-
-import org.apache.aurora.gen.AssignedTask;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.ScheduleStatus;
-import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskConfig;
-import org.apache.aurora.gen.TaskEvent;
-import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
-
-/**
- * Convenience methods for working with tasks.
- */
-public final class TaskTestUtil {
-
-  private TaskTestUtil() {
-    // Utility class.
-  }
-
-  public static IScheduledTask makeTask(ScheduleStatus status, List<TaskEvent> taskEvents) {
-    return IScheduledTask.build(new ScheduledTask()
-        .setStatus(status)
-        .setAssignedTask(new AssignedTask()
-            .setTaskId("task_id")
-            .setSlaveHost("host1")
-            .setTask(new TaskConfig()
-                .setJobName("job_a")
-                .setOwner(new Identity("role_a", "role_a" + "-user"))))
-        .setTaskEvents(taskEvents));
-  }
-
-  public static List<TaskEvent> makeTaskEvents(
-      long startTs,
-      ScheduleStatus status,
-      ScheduleStatus... statuses) {
-
-    ImmutableList.Builder<TaskEvent> taskEvents = ImmutableList.builder();
-    taskEvents.add(makeTaskEvent(startTs, status));
-    long increment = startTs;
-    for (ScheduleStatus st : statuses) {
-      taskEvents.add(makeTaskEvent(startTs + increment++, st));
-    }
-    return taskEvents.build();
-  }
-
-  private static TaskEvent makeTaskEvent(long ts, ScheduleStatus status) {
-    return new TaskEvent().setTimestamp(ts).setStatus(status);
-  }
-}

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/base/TasksTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/base/TasksTest.java b/src/test/java/org/apache/aurora/scheduler/base/TasksTest.java
index 2866b20..ed9a287 100644
--- a/src/test/java/org/apache/aurora/scheduler/base/TasksTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/base/TasksTest.java
@@ -22,8 +22,6 @@ import org.junit.Test;
 
 import static org.apache.aurora.gen.ScheduleStatus.FINISHED;
 import static org.apache.aurora.gen.ScheduleStatus.RUNNING;
-import static org.apache.aurora.scheduler.base.TaskTestUtil.makeTask;
-import static org.apache.aurora.scheduler.base.TaskTestUtil.makeTaskEvents;
 import static org.apache.aurora.scheduler.base.Tasks.getLatestActiveTask;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
@@ -43,12 +41,12 @@ public class TasksTest {
 
   @Test
   public void testLatestTransitionedTasks() {
-    IScheduledTask f1 = makeTask(FINISHED, makeTaskEvents(100, FINISHED));
-    IScheduledTask f2 = makeTask(FINISHED, makeTaskEvents(200, FINISHED));
-    IScheduledTask f3 = makeTask(FINISHED, makeTaskEvents(300, FINISHED));
-    IScheduledTask r1 = makeTask(RUNNING, makeTaskEvents(400, RUNNING));
-    IScheduledTask r2 = makeTask(RUNNING, makeTaskEvents(500, RUNNING));
-    IScheduledTask r3 = makeTask(RUNNING, makeTaskEvents(600, RUNNING));
+    IScheduledTask f1 = makeTask(FINISHED, 100);
+    IScheduledTask f2 = makeTask(FINISHED, 200);
+    IScheduledTask f3 = makeTask(FINISHED, 300);
+    IScheduledTask r1 = makeTask(RUNNING, 400);
+    IScheduledTask r2 = makeTask(RUNNING, 500);
+    IScheduledTask r3 = makeTask(RUNNING, 600);
 
     try {
       getLatestActiveTask(ImmutableList.<IScheduledTask>of());
@@ -78,4 +76,11 @@ public class TasksTest {
   private void assertLatestTask(IScheduledTask expectedLatest, IScheduledTask... tasks) {
     assertEquals(expectedLatest, getLatestActiveTask(ImmutableList.copyOf(tasks)));
   }
+
+  private IScheduledTask makeTask(ScheduleStatus status, long timestamp) {
+    return TaskTestUtil.addStateTransition(
+        TaskTestUtil.makeTask("id-" + timestamp, TaskTestUtil.JOB),
+        status,
+        timestamp);
+  }
 }

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/state/StateManagerImplTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/state/StateManagerImplTest.java b/src/test/java/org/apache/aurora/scheduler/state/StateManagerImplTest.java
index 7234fd3..c7fd3e5 100644
--- a/src/test/java/org/apache/aurora/scheduler/state/StateManagerImplTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/state/StateManagerImplTest.java
@@ -29,22 +29,25 @@ import com.twitter.common.testing.easymock.EasyMockTest;
 import com.twitter.common.util.testing.FakeClock;
 
 import org.apache.aurora.gen.AssignedTask;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.JobKey;
+import org.apache.aurora.gen.Attribute;
+import org.apache.aurora.gen.HostAttributes;
+import org.apache.aurora.gen.MaintenanceMode;
 import org.apache.aurora.gen.ScheduleStatus;
 import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskConfig;
 import org.apache.aurora.gen.TaskEvent;
 import org.apache.aurora.scheduler.TaskIdGenerator;
 import org.apache.aurora.scheduler.async.RescheduleCalculator;
 import org.apache.aurora.scheduler.base.Query;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
 import org.apache.aurora.scheduler.base.Tasks;
 import org.apache.aurora.scheduler.events.EventSink;
 import org.apache.aurora.scheduler.events.PubsubEvent;
 import org.apache.aurora.scheduler.events.PubsubEvent.TaskStateChange;
 import org.apache.aurora.scheduler.events.PubsubEvent.TasksDeleted;
 import org.apache.aurora.scheduler.mesos.Driver;
+import org.apache.aurora.scheduler.storage.AttributeStore;
 import org.apache.aurora.scheduler.storage.Storage;
+import org.apache.aurora.scheduler.storage.entities.IHostAttributes;
 import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
 import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
 import org.apache.aurora.scheduler.storage.mem.MemStorage;
@@ -75,9 +78,15 @@ import static org.junit.Assert.assertTrue;
 
 public class StateManagerImplTest extends EasyMockTest {
 
-  private static final String HOST_A = "host_a";
-  private static final Identity JIM = new Identity("jim", "jim-user");
-  private static final String MY_JOB = "myJob";
+  private static final IHostAttributes HOST_A = IHostAttributes.build(
+      new HostAttributes(
+          "hostA",
+          ImmutableSet.of(new Attribute("zone", ImmutableSet.of("1a"))))
+          .setSlaveId("slaveIdA")
+          .setMode(MaintenanceMode.NONE));
+  private static final ITaskConfig NON_SERVICE_CONFIG =
+      setIsService(TaskTestUtil.makeConfig(TaskTestUtil.JOB), false);
+  private static final ITaskConfig SERVICE_CONFIG = setIsService(NON_SERVICE_CONFIG, true);
 
   private Driver driver;
   private TaskIdGenerator taskIdGenerator;
@@ -101,6 +110,13 @@ public class StateManagerImplTest extends EasyMockTest {
         taskIdGenerator,
         eventSink,
         rescheduleCalculator);
+    storage.write(new Storage.MutateWork.NoResult.Quiet() {
+      @Override
+      protected void execute(Storage.MutableStoreProvider storeProvider) {
+        AttributeStore.Mutable attributeStore = storeProvider.getAttributeStore();
+        attributeStore.saveHostAttributes(HOST_A);
+      }
+    });
   }
 
   private static class StateChangeMatcher implements IArgumentMatcher {
@@ -167,14 +183,13 @@ public class StateManagerImplTest extends EasyMockTest {
 
   @Test
   public void testAddTasks() {
-    ITaskConfig task = makeTask(JIM, MY_JOB);
     String taskId = "a";
-    expect(taskIdGenerator.generate(task, 3)).andReturn(taskId);
+    expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 3)).andReturn(taskId);
     expectStateTransitions(taskId, INIT, PENDING);
 
     control.replay();
 
-    insertTask(task, 3);
+    insertTask(NON_SERVICE_CONFIG, 3);
     ScheduledTask expected = new ScheduledTask()
         .setStatus(PENDING)
         .setTaskEvents(ImmutableList.of(new TaskEvent()
@@ -184,37 +199,36 @@ public class StateManagerImplTest extends EasyMockTest {
         .setAssignedTask(new AssignedTask()
             .setInstanceId(3)
             .setTaskId(taskId)
-            .setTask(task.newBuilder()));
-    assertEquals(ImmutableSet.of(IScheduledTask.build(expected)),
+            .setTask(NON_SERVICE_CONFIG.newBuilder()));
+    assertEquals(
+        ImmutableSet.of(IScheduledTask.build(expected)),
         Storage.Util.fetchTasks(storage, Query.taskScoped(taskId)));
   }
 
   @Test
   public void testKillPendingTask() {
-    ITaskConfig task = makeTask(JIM, MY_JOB);
     String taskId = "a";
-    expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+    expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId);
     expectStateTransitions(taskId, INIT, PENDING);
     eventSink.post(matchTasksDeleted(taskId));
 
     control.replay();
 
-    insertTask(task, 0);
+    insertTask(NON_SERVICE_CONFIG, 0);
     assertEquals(true, changeState(taskId, KILLING));
     assertEquals(false, changeState(taskId, KILLING));
   }
 
   @Test
   public void testKillRunningTask() {
-    ITaskConfig task = makeTask(JIM, MY_JOB);
     String taskId = "a";
-    expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+    expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId);
     expectStateTransitions(taskId, INIT, PENDING, ASSIGNED, RUNNING, KILLING, KILLED);
     driver.killTask(EasyMock.<String>anyObject());
 
     control.replay();
 
-    insertTask(task, 0);
+    insertTask(NON_SERVICE_CONFIG, 0);
     assignTask(taskId, HOST_A);
     assertEquals(true, changeState(taskId, RUNNING));
     assertEquals(true, changeState(taskId, KILLING));
@@ -224,16 +238,15 @@ public class StateManagerImplTest extends EasyMockTest {
 
   @Test
   public void testLostKillingTask() {
-    ITaskConfig task = makeTask(JIM, MY_JOB);
     String taskId = "a";
-    expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+    expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId);
     expectStateTransitions(taskId, INIT, PENDING, ASSIGNED, RUNNING, KILLING, LOST);
 
     driver.killTask(EasyMock.<String>anyObject());
 
     control.replay();
 
-    insertTask(task, 0);
+    insertTask(NON_SERVICE_CONFIG, 0);
 
     assignTask(taskId, HOST_A);
     changeState(taskId, RUNNING);
@@ -244,8 +257,7 @@ public class StateManagerImplTest extends EasyMockTest {
   @Test
   public void testNestedEvents() {
     final String id = "a";
-    ITaskConfig task = makeTask(JIM, MY_JOB);
-    expect(taskIdGenerator.generate(task, 0)).andReturn(id);
+    expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(id);
 
     // Trigger an event that produces a side-effect and a PubSub event .
     eventSink.post(matchStateChange(id, INIT, PENDING));
@@ -262,26 +274,29 @@ public class StateManagerImplTest extends EasyMockTest {
 
     control.replay();
 
-    insertTask(task, 0);
+    insertTask(NON_SERVICE_CONFIG, 0);
   }
 
   @Test
   public void testDeletePendingTask() {
-    ITaskConfig task = makeTask(JIM, MY_JOB);
     String taskId = "a";
-    expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+    expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId);
     expectStateTransitions(taskId, INIT, PENDING);
     eventSink.post(matchTasksDeleted(taskId));
 
     control.replay();
 
-    insertTask(task, 0);
+    insertTask(NON_SERVICE_CONFIG, 0);
     changeState(taskId, KILLING);
   }
 
+  private static ITaskConfig setIsService(ITaskConfig config, boolean service) {
+    return ITaskConfig.build(config.newBuilder().setIsService(service));
+  }
+
   @Test
   public void testThrottleTask() {
-    ITaskConfig task = ITaskConfig.build(makeTask(JIM, MY_JOB).newBuilder().setIsService(true));
+    ITaskConfig task = setIsService(NON_SERVICE_CONFIG, true);
     String taskId = "a";
     expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
     expectStateTransitions(taskId, INIT, PENDING, ASSIGNED, RUNNING, FAILED);
@@ -317,19 +332,18 @@ public class StateManagerImplTest extends EasyMockTest {
 
   @Test
   public void testIncrementFailureCount() {
-    ITaskConfig task = ITaskConfig.build(makeTask(JIM, MY_JOB).newBuilder().setIsService(true));
     String taskId = "a";
-    expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+    expect(taskIdGenerator.generate(SERVICE_CONFIG, 0)).andReturn(taskId);
     expectStateTransitions(taskId, INIT, PENDING, ASSIGNED, RUNNING, FAILED);
 
     String taskId2 = "a2";
-    expect(taskIdGenerator.generate(task, 0)).andReturn(taskId2);
+    expect(taskIdGenerator.generate(SERVICE_CONFIG, 0)).andReturn(taskId2);
     noFlappingPenalty();
     expectStateTransitions(taskId2, INIT, PENDING);
 
     control.replay();
 
-    insertTask(task, 0);
+    insertTask(SERVICE_CONFIG, 0);
 
     assignTask(taskId, HOST_A);
     changeState(taskId, RUNNING);
@@ -340,16 +354,20 @@ public class StateManagerImplTest extends EasyMockTest {
     assertEquals(1, rescheduledTask.getFailureCount());
   }
 
+  private static ITaskConfig setMaxFailures(ITaskConfig config, int maxFailures) {
+    return ITaskConfig.build(config.newBuilder().setMaxTaskFailures(maxFailures));
+  }
+
   @Test
   public void testCasTaskPresent() {
-    ITaskConfig task = makeTask(JIM, MY_JOB);
     String taskId = "a";
-    expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+    ITaskConfig config = setMaxFailures(NON_SERVICE_CONFIG, 1);
+    expect(taskIdGenerator.generate(config, 0)).andReturn(taskId);
     expectStateTransitions(taskId, INIT, PENDING, ASSIGNED, FAILED);
 
     control.replay();
 
-    insertTask(task, 0);
+    insertTask(config, 0);
     assignTask(taskId, HOST_A);
     assertFalse(changeState(
         taskId,
@@ -376,15 +394,14 @@ public class StateManagerImplTest extends EasyMockTest {
 
   @Test
   public void testDeleteTasks() {
-    ITaskConfig task = makeTask(JIM, MY_JOB);
     final String taskId = "a";
-    expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+    expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId);
     expectStateTransitions(taskId, INIT, PENDING, ASSIGNED, RUNNING, FINISHED);
     eventSink.post(matchTasksDeleted(taskId));
 
     control.replay();
 
-    insertTask(task, 0);
+    insertTask(NON_SERVICE_CONFIG, 0);
     assignTask(taskId, HOST_A);
     changeState(taskId, RUNNING);
     changeState(taskId, FINISHED);
@@ -394,14 +411,16 @@ public class StateManagerImplTest extends EasyMockTest {
         stateManager.deleteTasks(storeProvider, ImmutableSet.of(taskId));
       }
     });
+  }
 
+  private static ITaskConfig setRequestedPorts(ITaskConfig config, Set<String> portNames) {
+    return ITaskConfig.build(config.newBuilder().setRequestedPorts(portNames));
   }
 
   @Test
   public void testPortResource() throws Exception {
     Set<String> requestedPorts = ImmutableSet.of("one", "two", "three");
-    ITaskConfig task = ITaskConfig.build(makeTask(JIM, MY_JOB).newBuilder()
-        .setRequestedPorts(requestedPorts));
+    ITaskConfig task = setRequestedPorts(NON_SERVICE_CONFIG, requestedPorts);
 
     String taskId = "a";
     expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
@@ -423,8 +442,7 @@ public class StateManagerImplTest extends EasyMockTest {
   @Test
   public void testPortResourceResetAfterReschedule() throws Exception {
     Set<String> requestedPorts = ImmutableSet.of("one");
-    ITaskConfig task = ITaskConfig.build(makeTask(JIM, MY_JOB).newBuilder()
-        .setRequestedPorts(requestedPorts));
+    ITaskConfig task = setRequestedPorts(NON_SERVICE_CONFIG, requestedPorts);
 
     String taskId = "a";
     expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
@@ -458,7 +476,7 @@ public class StateManagerImplTest extends EasyMockTest {
       protected void execute(Storage.MutableStoreProvider storeProvider) {
         stateManager.insertPendingTasks(
             storeProvider,
-            makeTask(JIM, MY_JOB),
+            NON_SERVICE_CONFIG,
             ImmutableSet.<Integer>of());
       }
     });
@@ -466,26 +484,24 @@ public class StateManagerImplTest extends EasyMockTest {
 
   @Test(expected = IllegalArgumentException.class)
   public void insertPendingInstancesInstanceCollision() {
-    ITaskConfig task = makeTask(JIM, MY_JOB);
     String taskId = "a";
-    expect(taskIdGenerator.generate(task, 0)).andReturn(taskId).times(2);
+    expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId).times(2);
     expectStateTransitions(taskId, INIT, PENDING);
 
     control.replay();
 
-    insertTask(task, 0);
+    insertTask(NON_SERVICE_CONFIG, 0);
     Iterables.getOnlyElement(Storage.Util.fetchTasks(storage, Query.taskScoped(taskId)));
 
-    insertTask(task, 0);
+    insertTask(NON_SERVICE_CONFIG, 0);
   }
 
   @Test
   public void testAssignTaskPubsub() {
     // This test ensures the pubsub events emitted by assigning tasks have slave id and host set.
-    ITaskConfig task = makeTask(JIM, MY_JOB);
     String taskId = "a";
 
-    expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+    expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId);
 
     expectStateTransitions(taskId, INIT, PENDING);
 
@@ -494,13 +510,13 @@ public class StateManagerImplTest extends EasyMockTest {
 
     control.replay();
 
-    insertTask(task, 0);
+    insertTask(NON_SERVICE_CONFIG, 0);
     assignTask(taskId, HOST_A);
 
     TaskStateChange change = taskStateChangeCapture.getValue();
     assertEquals(ASSIGNED, change.getNewState());
-    assertEquals(HOST_A, change.getTask().getAssignedTask().getSlaveHost());
-    assertEquals(HOST_A, change.getTask().getAssignedTask().getSlaveId());
+    assertEquals(HOST_A.getHost(), change.getTask().getAssignedTask().getSlaveHost());
+    assertEquals(HOST_A.getSlaveId(), change.getTask().getAssignedTask().getSlaveId());
   }
 
   private void expectStateTransitions(
@@ -561,22 +577,13 @@ public class StateManagerImplTest extends EasyMockTest {
         Optional.<String>absent());
   }
 
-  private static ITaskConfig makeTask(Identity owner, String job) {
-    return ITaskConfig.build(new TaskConfig()
-        .setJob(new JobKey(owner.getRole(), "devel", job))
-        .setOwner(owner)
-        .setEnvironment("devel")
-        .setJobName(job)
-        .setRequestedPorts(ImmutableSet.<String>of()));
-  }
-
-  private void assignTask(String taskId, String host) {
+  private void assignTask(String taskId, IHostAttributes host) {
     assignTask(taskId, host, ImmutableMap.<String, Integer>of());
   }
 
   private void assignTask(
       final String taskId,
-      final String host,
+      final IHostAttributes host,
       final Map<String, Integer> ports) {
 
     storage.write(new Storage.MutateWork.NoResult.Quiet() {
@@ -585,8 +592,8 @@ public class StateManagerImplTest extends EasyMockTest {
         stateManager.assignTask(
             storeProvider,
             taskId,
-            host,
-            SlaveID.newBuilder().setValue(host).build(),
+            host.getHost(),
+            SlaveID.newBuilder().setValue(host.getSlaveId()).build(),
             ports);
       }
     });

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/stats/ResourceCounterTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/stats/ResourceCounterTest.java b/src/test/java/org/apache/aurora/scheduler/stats/ResourceCounterTest.java
index e5f3adf..82e9c76 100644
--- a/src/test/java/org/apache/aurora/scheduler/stats/ResourceCounterTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/stats/ResourceCounterTest.java
@@ -21,10 +21,7 @@ import com.google.common.base.Predicates;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 
-import org.apache.aurora.gen.AssignedTask;
 import org.apache.aurora.gen.Constraint;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.JobKey;
 import org.apache.aurora.gen.ResourceAggregate;
 import org.apache.aurora.gen.ScheduleStatus;
 import org.apache.aurora.gen.ScheduledTask;
@@ -33,6 +30,7 @@ import org.apache.aurora.gen.TaskConstraint;
 import org.apache.aurora.gen.ValueConstraint;
 import org.apache.aurora.scheduler.base.JobKeys;
 import org.apache.aurora.scheduler.base.Query;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
 import org.apache.aurora.scheduler.configuration.ConfigurationManager;
 import org.apache.aurora.scheduler.storage.Storage;
 import org.apache.aurora.scheduler.storage.entities.IJobKey;
@@ -167,28 +165,21 @@ public class ResourceCounterTest {
       ScheduleStatus status,
       Optional<String> dedicated) {
 
-    TaskConfig task = new TaskConfig()
-        .setJob(new JobKey(role, "test", job))
-        .setOwner(new Identity().setRole(role))
-        .setEnvironment("test")
-        .setJobName(job)
+    ScheduledTask task = TaskTestUtil.makeTask(id, JobKeys.from(role, "test", job)).newBuilder();
+    TaskConfig config = task.getAssignedTask().getTask()
         .setNumCpus(numCpus)
         .setRamMb(ramMb)
         .setDiskMb(diskMb)
         .setProduction(production);
 
     if (dedicated.isPresent()) {
-      task.addToConstraints(new Constraint(
+      config.addToConstraints(new Constraint(
           ConfigurationManager.DEDICATED_ATTRIBUTE,
           TaskConstraint.value(new ValueConstraint(false, ImmutableSet.of(dedicated.get())))));
     }
 
-    return IScheduledTask.build(new ScheduledTask()
-        .setStatus(status)
-        .setAssignedTask(
-            new AssignedTask()
-                .setTaskId(id)
-                .setTask(task)));
+    task.setStatus(status);
+    return IScheduledTask.build(task);
   }
 
   private void insertTasks(final IScheduledTask... tasks) {

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/storage/StorageBackfillTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/storage/StorageBackfillTest.java b/src/test/java/org/apache/aurora/scheduler/storage/StorageBackfillTest.java
index 90a05ba..254b231 100644
--- a/src/test/java/org/apache/aurora/scheduler/storage/StorageBackfillTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/storage/StorageBackfillTest.java
@@ -15,50 +15,34 @@ package org.apache.aurora.scheduler.storage;
 
 import java.util.Set;
 
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
 
-import org.apache.aurora.gen.AssignedTask;
-import org.apache.aurora.gen.Constraint;
 import org.apache.aurora.gen.Container;
-import org.apache.aurora.gen.ExecutorConfig;
-import org.apache.aurora.gen.Identity;
 import org.apache.aurora.gen.JobConfiguration;
-import org.apache.aurora.gen.JobKey;
 import org.apache.aurora.gen.MesosContainer;
 import org.apache.aurora.gen.ScheduledTask;
 import org.apache.aurora.gen.TaskConfig;
-import org.apache.aurora.gen.TaskEvent;
-import org.apache.aurora.scheduler.base.JobKeys;
 import org.apache.aurora.scheduler.base.Query;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
 import org.apache.aurora.scheduler.configuration.ConfigurationManager;
 import org.apache.aurora.scheduler.configuration.SanitizedConfiguration;
 import org.apache.aurora.scheduler.storage.entities.IJobConfiguration;
-import org.apache.aurora.scheduler.storage.entities.IJobKey;
 import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
-import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
 import org.apache.aurora.scheduler.storage.mem.MemStorage;
 import org.junit.Before;
 import org.junit.Test;
 
-import static org.apache.aurora.gen.ScheduleStatus.PENDING;
-import static org.apache.aurora.gen.ScheduleStatus.RUNNING;
 import static org.junit.Assert.assertEquals;
 
+/**
+ * TODO(wfarner): Data store constraints (not null, valid relations) have made this test of little
+ * value other than for coverage.  Rethink.
+ */
 public class StorageBackfillTest {
-  private static final String ROLE = "Test_Role_A";
-  private static final String USER = "Test_User_A";
-  private static final Identity OWNER = new Identity(ROLE, USER);
-  private static final String ENV = "Test_Env";
-  private static final String JOB_NAME = "Test_Job";
-  private static final IJobKey JOB_KEY = JobKeys.from(ROLE, ENV, JOB_NAME);
-  private static final int ONE_GB = 1024;
-  private static final String TASK_ID = "task_id";
-  private static final ExecutorConfig EXECUTOR_CONFIG =
-      new ExecutorConfig("AuroraExecutor", "executorConfig");
+  // By default, only the mesos container is allowed by ConfigurationManager.
+  private static final IScheduledTask TASK =
+      setMesosContainer(TaskTestUtil.makeTask("task_id", TaskTestUtil.JOB));
 
   private Storage storage;
 
@@ -68,40 +52,14 @@ public class StorageBackfillTest {
   }
 
   @Test
-  public void testLoadTasksFromStorage() throws Exception {
-    final TaskConfig storedTask = defaultTask();
-
-    storage.write(new Storage.MutateWork.NoResult.Quiet() {
-      @Override
-      protected void execute(Storage.MutableStoreProvider storeProvider) {
-        storeProvider.getUnsafeTaskStore().saveTasks(ImmutableSet.of(
-            IScheduledTask.build(new ScheduledTask()
-                .setStatus(PENDING)
-                .setTaskEvents(ImmutableList.of(new TaskEvent(100, PENDING)))
-                .setAssignedTask(new AssignedTask()
-                    .setTaskId(TASK_ID)
-                    .setInstanceId(0)
-                    .setTask(storedTask)))));
-      }
-    });
-
-    backfill();
-
-    // Since task fields are backfilled with defaults, additional flags should be filled.
-    ITaskConfig expected = ITaskConfig.build(new TaskConfig(storedTask)
-        .setJob(JOB_KEY.newBuilder())
-        .setProduction(false)
-        .setMaxTaskFailures(1)
-        .setExecutorConfig(EXECUTOR_CONFIG)
-        .setContainer(Container.mesos(new MesosContainer()))
-        .setConstraints(ImmutableSet.of(ConfigurationManager.hostLimitConstraint(1))));
-
-    assertEquals(expected, getTask(TASK_ID).getAssignedTask().getTask());
-  }
-
-  @Test
   public void testJobConfigurationBackfill() throws Exception {
-    final JobConfiguration config = makeJobConfig(JOB_KEY, defaultTask(), 1);
+    TaskConfig task = TASK.getAssignedTask().getTask().newBuilder();
+    final JobConfiguration config = new JobConfiguration()
+        .setOwner(task.getOwner())
+        .setKey(task.getJob())
+        .setInstanceCount(1)
+        .setTaskConfig(task);
+
     SanitizedConfiguration expected =
         SanitizedConfiguration.fromUnsanitized(IJobConfiguration.build(config));
 
@@ -128,25 +86,11 @@ public class StorageBackfillTest {
   }
 
   @Test
-  public void testBackfillTaskJob() throws Exception {
-    TaskConfig task = defaultTask();
-    ConfigurationManager.applyDefaultsIfUnset(task);
-    task.unsetJob();
-
-    IScheduledTask noJobKey = IScheduledTask.build(new ScheduledTask()
-        .setStatus(RUNNING)
-        .setAssignedTask(new AssignedTask()
-            .setInstanceId(0)
-            .setTaskId("nojobkey")
-            .setTask(task)));
-    IScheduledTask nullJobKeyFields = IScheduledTask.build(new ScheduledTask()
-        .setStatus(RUNNING)
-        .setAssignedTask(new AssignedTask()
-            .setInstanceId(1)
-            .setTaskId("nulled_fields")
-            .setTask(task.setJob(new JobKey()))));
-
-    final Set<IScheduledTask> backfilledTasks = ImmutableSet.of(noJobKey, nullJobKeyFields);
+  public void testBackfillTask() throws Exception {
+    ScheduledTask task = TASK.newBuilder();
+    ConfigurationManager.applyDefaultsIfUnset(task.getAssignedTask().getTask());
+
+    final Set<IScheduledTask> backfilledTasks = ImmutableSet.of(IScheduledTask.build(task));
     storage.write(new Storage.MutateWork.NoResult.Quiet() {
       @Override
       protected void execute(Storage.MutableStoreProvider storeProvider) {
@@ -155,18 +99,9 @@ public class StorageBackfillTest {
     });
 
     backfill();
-    ScheduledTask noJobKeyBackfilled = noJobKey.newBuilder();
-    noJobKeyBackfilled.getAssignedTask().getTask()
-        .setJob(new JobKey(OWNER.getRole(), ENV, JOB_NAME));
-
-    ScheduledTask nullJobKeyFieldsBackfilled = nullJobKeyFields.newBuilder();
-    nullJobKeyFieldsBackfilled.getAssignedTask().getTask()
-        .setJob(new JobKey(OWNER.getRole(), ENV, JOB_NAME));
 
     assertEquals(
-        ImmutableSet.of(
-            IScheduledTask.build(noJobKeyBackfilled),
-            IScheduledTask.build(nullJobKeyFieldsBackfilled)),
+        ImmutableSet.of(IScheduledTask.build(task)),
         Storage.Util.fetchTasks(storage, Query.unscoped()));
   }
 
@@ -179,34 +114,9 @@ public class StorageBackfillTest {
     });
   }
 
-  private static JobConfiguration makeJobConfig(IJobKey jobKey, TaskConfig task, int numTasks) {
-    return new JobConfiguration()
-        .setOwner(OWNER)
-        .setKey(jobKey.newBuilder())
-        .setInstanceCount(numTasks)
-        .setTaskConfig(new TaskConfig(task)
-            .setOwner(OWNER)
-            .setEnvironment(jobKey.getEnvironment())
-            .setJobName(jobKey.getName()));
-  }
-
-  private static TaskConfig defaultTask() {
-    return new TaskConfig()
-        .setOwner(OWNER)
-        .setJobName(JOB_NAME)
-        .setEnvironment(ENV)
-        .setNumCpus(1.0)
-        .setRamMb(ONE_GB)
-        .setDiskMb(500)
-        .setExecutorConfig(EXECUTOR_CONFIG)
-        .setRequestedPorts(Sets.<String>newHashSet())
-        .setConstraints(Sets.<Constraint>newHashSet())
-        .setTaskLinks(Maps.<String, String>newHashMap());
-  }
-
-  private IScheduledTask getTask(String taskId) {
-    return Iterables.getOnlyElement(Storage.Util.fetchTasks(
-        storage,
-        Query.taskScoped(taskId)));
+  private static IScheduledTask setMesosContainer(IScheduledTask task) {
+    ScheduledTask builder = task.newBuilder();
+    builder.getAssignedTask().getTask().setContainer(Container.mesos(new MesosContainer()));
+    return IScheduledTask.build(builder);
   }
 }

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/storage/backup/RecoveryTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/storage/backup/RecoveryTest.java b/src/test/java/org/apache/aurora/scheduler/storage/backup/RecoveryTest.java
index 5853c03..09e4208 100644
--- a/src/test/java/org/apache/aurora/scheduler/storage/backup/RecoveryTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/storage/backup/RecoveryTest.java
@@ -25,18 +25,15 @@ import com.twitter.common.quantity.Time;
 import com.twitter.common.testing.easymock.EasyMockTest;
 import com.twitter.common.util.testing.FakeClock;
 
-import org.apache.aurora.gen.AssignedTask;
 import org.apache.aurora.gen.HostAttributes;
-import org.apache.aurora.gen.Identity;
 import org.apache.aurora.gen.Lock;
-import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskConfig;
 import org.apache.aurora.gen.storage.QuotaConfiguration;
 import org.apache.aurora.gen.storage.SchedulerMetadata;
 import org.apache.aurora.gen.storage.Snapshot;
 import org.apache.aurora.gen.storage.StoredCronJob;
 import org.apache.aurora.gen.storage.StoredJobUpdateDetails;
 import org.apache.aurora.scheduler.base.Query;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
 import org.apache.aurora.scheduler.base.Tasks;
 import org.apache.aurora.scheduler.storage.DistributedSnapshotStore;
 import org.apache.aurora.scheduler.storage.SnapshotStore;
@@ -62,8 +59,8 @@ import static org.junit.Assert.assertEquals;
 public class RecoveryTest extends EasyMockTest {
 
   private static final Amount<Long, Time> INTERVAL = Amount.of(1L, Time.HOURS);
-  private static final ScheduledTask TASK1 = makeTask("task1");
-  private static final ScheduledTask TASK2 = makeTask("task2");
+  private static final IScheduledTask TASK1 = TaskTestUtil.makeTask("task1", TaskTestUtil.JOB);
+  private static final IScheduledTask TASK2 = TaskTestUtil.makeTask("task2", TaskTestUtil.JOB);
   private static final Snapshot SNAPSHOT1 = makeSnapshot(TASK1, TASK2);
 
   private SnapshotStore<Snapshot> snapshotStore;
@@ -129,7 +126,7 @@ public class RecoveryTest extends EasyMockTest {
   @Test
   public void testModifySnapshotBeforeCommit() throws Exception {
     expect(snapshotStore.createSnapshot()).andReturn(SNAPSHOT1);
-    Snapshot modified = SNAPSHOT1.deepCopy().setTasks(ImmutableSet.of(TASK1));
+    Snapshot modified = SNAPSHOT1.deepCopy().setTasks(ImmutableSet.of(TASK1.newBuilder()));
     Capture<MutateWork<Object, Exception>> transaction = createCapture();
     expect(primaryStorage.write(capture(transaction))).andReturn(null);
     distributedStore.persist(modified);
@@ -164,24 +161,14 @@ public class RecoveryTest extends EasyMockTest {
     recovery.commit();
   }
 
-  private static Snapshot makeSnapshot(ScheduledTask... tasks) {
+  private static Snapshot makeSnapshot(IScheduledTask... tasks) {
     return new Snapshot()
         .setHostAttributes(ImmutableSet.<HostAttributes>of())
         .setCronJobs(ImmutableSet.<StoredCronJob>of())
         .setSchedulerMetadata(new SchedulerMetadata().setVersion(CURRENT_API_VERSION))
         .setQuotaConfigurations(ImmutableSet.<QuotaConfiguration>of())
-        .setTasks(ImmutableSet.<ScheduledTask>builder().add(tasks).build())
+        .setTasks(IScheduledTask.toBuildersSet(ImmutableSet.copyOf(tasks)))
         .setLocks(ImmutableSet.<Lock>of())
         .setJobUpdateDetails(ImmutableSet.<StoredJobUpdateDetails>of());
   }
-
-  private static ScheduledTask makeTask(String taskId) {
-    return new ScheduledTask().setAssignedTask(
-        new AssignedTask()
-            .setTaskId(taskId)
-            .setTask(new TaskConfig()
-                .setJobName("job-" + taskId)
-                .setEnvironment("test")
-                .setOwner(new Identity().setRole("role-" + taskId).setUser("user-" + taskId))));
-  }
 }


[2/3] aurora git commit: Require non-default primitive values in StorageEntityUtil.

Posted by wf...@apache.org.
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/storage/db/DBJobUpdateStoreTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/storage/db/DBJobUpdateStoreTest.java b/src/test/java/org/apache/aurora/scheduler/storage/db/DBJobUpdateStoreTest.java
deleted file mode 100644
index 1f50515..0000000
--- a/src/test/java/org/apache/aurora/scheduler/storage/db/DBJobUpdateStoreTest.java
+++ /dev/null
@@ -1,1076 +0,0 @@
-/**
- * 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 org.apache.aurora.scheduler.storage.db;
-
-import java.util.List;
-import java.util.Set;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-
-import org.apache.aurora.gen.Constraint;
-import org.apache.aurora.gen.ExecutorConfig;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.InstanceTaskConfig;
-import org.apache.aurora.gen.JobInstanceUpdateEvent;
-import org.apache.aurora.gen.JobKey;
-import org.apache.aurora.gen.JobUpdate;
-import org.apache.aurora.gen.JobUpdateAction;
-import org.apache.aurora.gen.JobUpdateDetails;
-import org.apache.aurora.gen.JobUpdateEvent;
-import org.apache.aurora.gen.JobUpdateInstructions;
-import org.apache.aurora.gen.JobUpdateKey;
-import org.apache.aurora.gen.JobUpdateQuery;
-import org.apache.aurora.gen.JobUpdateSettings;
-import org.apache.aurora.gen.JobUpdateState;
-import org.apache.aurora.gen.JobUpdateStatus;
-import org.apache.aurora.gen.JobUpdateSummary;
-import org.apache.aurora.gen.Lock;
-import org.apache.aurora.gen.LockKey;
-import org.apache.aurora.gen.Metadata;
-import org.apache.aurora.gen.Range;
-import org.apache.aurora.gen.TaskConfig;
-import org.apache.aurora.gen.TaskConstraint;
-import org.apache.aurora.gen.ValueConstraint;
-import org.apache.aurora.gen.storage.StoredJobUpdateDetails;
-import org.apache.aurora.scheduler.base.JobKeys;
-import org.apache.aurora.scheduler.storage.Storage;
-import org.apache.aurora.scheduler.storage.Storage.MutableStoreProvider;
-import org.apache.aurora.scheduler.storage.Storage.MutateWork;
-import org.apache.aurora.scheduler.storage.Storage.StorageException;
-import org.apache.aurora.scheduler.storage.Storage.Work.Quiet;
-import org.apache.aurora.scheduler.storage.entities.IJobInstanceUpdateEvent;
-import org.apache.aurora.scheduler.storage.entities.IJobKey;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdate;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdateDetails;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdateEvent;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdateInstructions;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdateKey;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdateQuery;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdateSummary;
-import org.apache.aurora.scheduler.storage.entities.ILock;
-import org.apache.aurora.scheduler.storage.testing.StorageEntityUtil;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_ROLLBACK_FAILED;
-import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_ROLLED_BACK;
-import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_ROLLING_BACK;
-import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_UPDATED;
-import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_UPDATING;
-import static org.apache.aurora.gen.JobUpdateStatus.ABORTED;
-import static org.apache.aurora.gen.JobUpdateStatus.ERROR;
-import static org.apache.aurora.gen.JobUpdateStatus.FAILED;
-import static org.apache.aurora.gen.JobUpdateStatus.ROLLED_BACK;
-import static org.apache.aurora.gen.JobUpdateStatus.ROLLING_BACK;
-import static org.apache.aurora.gen.JobUpdateStatus.ROLLING_FORWARD;
-import static org.apache.aurora.gen.JobUpdateStatus.ROLL_BACK_PAUSED;
-import static org.apache.aurora.gen.JobUpdateStatus.ROLL_FORWARD_PAUSED;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-
-public class DBJobUpdateStoreTest {
-
-  private static final IJobKey JOB = JobKeys.from("testRole", "testEnv", "job");
-  private static final IJobUpdateKey UPDATE1 =
-      IJobUpdateKey.build(new JobUpdateKey(JOB.newBuilder(), "update1"));
-  private static final IJobUpdateKey UPDATE2 = IJobUpdateKey.build(
-      new JobUpdateKey(JobKeys.from("testRole", "testEnv", "job2").newBuilder(), "update2"));
-  private static final long CREATED_MS = 111L;
-  private static final IJobUpdateEvent FIRST_EVENT =
-      makeJobUpdateEvent(ROLLING_FORWARD, CREATED_MS);
-
-  private Storage storage;
-
-  @Before
-  public void setUp() throws Exception {
-    storage = DbUtil.createStorage();
-  }
-
-  @After
-  public void tearDown() throws Exception {
-    truncateUpdates();
-  }
-
-  @Test
-  public void testSaveJobUpdates() {
-    IJobUpdateKey updateId1 = makeKey(JobKeys.from("role", "env", "name1"), "u1");
-    IJobUpdateKey updateId2 = makeKey(JobKeys.from("role", "env", "name2"), "u2");
-
-    IJobUpdate update1 = makeJobUpdate(updateId1);
-    IJobUpdate update2 = makeJobUpdate(updateId2);
-
-    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId1));
-    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId2));
-
-    StorageEntityUtil.assertFullyPopulated(
-        update1,
-        StorageEntityUtil.getField(JobUpdateSummary.class, "state"),
-        StorageEntityUtil.getField(IJobUpdateSummary.class, "state"));
-    saveUpdate(update1, Optional.of("lock1"));
-    assertUpdate(update1);
-
-    saveUpdate(update2, Optional.<String>absent());
-    assertUpdate(update2);
-
-    // Colliding update IDs should be forbidden.
-    IJobUpdate update3 =
-        makeJobUpdate(makeKey(JobKeys.from("role", "env", "name3"), updateId2.getId()));
-    try {
-      saveUpdate(update3, Optional.<String>absent());
-      fail("Update ID collision should not be allowed");
-    } catch (StorageException e) {
-      // Expected.
-    }
-  }
-
-  @Test
-  public void testSaveNullInitialState() {
-    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
-    builder.getInstructions().unsetInitialState();
-
-    // Save with null initial state instances.
-    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
-
-    builder.getInstructions().setInitialState(ImmutableSet.<InstanceTaskConfig>of());
-    assertUpdate(IJobUpdate.build(builder));
-  }
-
-  @Test
-  public void testSaveNullDesiredState() {
-    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
-    builder.getInstructions().unsetDesiredState();
-
-    // Save with null desired state instances.
-    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
-
-    assertUpdate(IJobUpdate.build(builder));
-  }
-
-  @Test(expected = IllegalArgumentException.class)
-  public void testSaveBothInitialAndDesiredMissingThrows() {
-    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
-    builder.getInstructions().unsetInitialState();
-    builder.getInstructions().unsetDesiredState();
-
-    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
-  }
-
-  @Test(expected = NullPointerException.class)
-  public void testSaveNullInitialStateTaskThrows() {
-    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
-    builder.getInstructions().getInitialState().add(
-        new InstanceTaskConfig(null, ImmutableSet.<Range>of()));
-
-    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
-  }
-
-  @Test(expected = IllegalArgumentException.class)
-  public void testSaveEmptyInitialStateRangesThrows() {
-    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
-    builder.getInstructions().getInitialState().add(
-        new InstanceTaskConfig(new TaskConfig(), ImmutableSet.<Range>of()));
-
-    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
-  }
-
-  @Test(expected = NullPointerException.class)
-  public void testSaveNullDesiredStateTaskThrows() {
-    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
-    builder.getInstructions().getDesiredState().setTask(null);
-
-    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
-  }
-
-  @Test(expected = IllegalArgumentException.class)
-  public void testSaveEmptyDesiredStateRangesThrows() {
-    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
-    builder.getInstructions().getDesiredState().setInstances(ImmutableSet.<Range>of());
-
-    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
-  }
-
-  @Test
-  public void testSaveJobUpdateEmptyInstanceOverrides() {
-    IJobUpdateKey updateId = makeKey("u1");
-
-    IJobUpdate update = makeJobUpdate(updateId);
-    JobUpdate builder = update.newBuilder();
-    builder.getInstructions().getSettings().setUpdateOnlyTheseInstances(ImmutableSet.<Range>of());
-
-    IJobUpdate expected = IJobUpdate.build(builder);
-
-    // Save with empty overrides.
-    saveUpdate(expected, Optional.of("lock"));
-    assertUpdate(expected);
-  }
-
-  @Test
-  public void testSaveJobUpdateNullInstanceOverrides() {
-    IJobUpdateKey updateId = makeKey("u1");
-
-    IJobUpdate update = makeJobUpdate(updateId);
-    JobUpdate builder = update.newBuilder();
-    builder.getInstructions().getSettings().setUpdateOnlyTheseInstances(ImmutableSet.<Range>of());
-
-    IJobUpdate expected = IJobUpdate.build(builder);
-
-    // Save with null overrides.
-    builder.getInstructions().getSettings().setUpdateOnlyTheseInstances(null);
-    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
-    assertUpdate(expected);
-  }
-
-  @Test(expected = StorageException.class)
-  public void testSaveJobUpdateTwiceThrows() {
-    IJobUpdateKey updateId = makeKey("u1");
-    IJobUpdate update = makeJobUpdate(updateId);
-
-    saveUpdate(update, Optional.of("lock1"));
-    saveUpdate(update, Optional.of("lock2"));
-  }
-
-  @Test
-  public void testSaveJobEvents() {
-    IJobUpdateKey updateId = makeKey("u3");
-    IJobUpdate update = makeJobUpdate(updateId);
-    IJobUpdateEvent event1 = makeJobUpdateEvent(ROLLING_FORWARD, 124L);
-    IJobUpdateEvent event2 = makeJobUpdateEvent(ROLL_FORWARD_PAUSED, 125L);
-
-    saveUpdate(update, Optional.of("lock1"));
-    assertUpdate(update);
-    assertEquals(ImmutableList.of(FIRST_EVENT), getUpdateDetails(updateId).get().getUpdateEvents());
-
-    saveJobEvent(event1, updateId);
-    assertEquals(
-        populateExpected(update, ROLLING_FORWARD, CREATED_MS, 124L),
-        getUpdateDetails(updateId).get().getUpdate());
-    assertEquals(event1, getUpdateDetails(updateId).get().getUpdateEvents().get(1));
-
-    saveJobEvent(event2, updateId);
-    assertEquals(
-        populateExpected(update, ROLL_FORWARD_PAUSED, CREATED_MS, 125L),
-        getUpdateDetails(updateId).get().getUpdate());
-    assertEquals(event1, getUpdateDetails(updateId).get().getUpdateEvents().get(1));
-    assertEquals(event2, getUpdateDetails(updateId).get().getUpdateEvents().get(2));
-  }
-
-  @Test
-  public void testSaveInstanceEvents() {
-    IJobUpdateKey updateId = makeKey("u3");
-    IJobUpdate update = makeJobUpdate(updateId);
-    IJobInstanceUpdateEvent event1 = makeJobInstanceEvent(0, 125L, INSTANCE_UPDATED);
-    IJobInstanceUpdateEvent event2 = makeJobInstanceEvent(1, 126L, INSTANCE_ROLLING_BACK);
-
-    saveUpdate(update, Optional.of("lock"));
-    assertUpdate(update);
-    assertEquals(0, getUpdateDetails(updateId).get().getInstanceEvents().size());
-
-    saveJobInstanceEvent(event1, updateId);
-    assertEquals(
-        populateExpected(update, ROLLING_FORWARD, CREATED_MS, 125L),
-        getUpdateDetails(updateId).get().getUpdate());
-    assertEquals(
-        event1,
-        Iterables.getOnlyElement(getUpdateDetails(updateId).get().getInstanceEvents()));
-
-    saveJobInstanceEvent(event2, updateId);
-    assertEquals(
-        populateExpected(update, ROLLING_FORWARD, CREATED_MS, 126L),
-        getUpdateDetails(updateId).get().getUpdate());
-    assertEquals(event1, getUpdateDetails(updateId).get().getInstanceEvents().get(0));
-    assertEquals(event2, getUpdateDetails(updateId).get().getInstanceEvents().get(1));
-  }
-
-  @Test(expected = StorageException.class)
-  public void testSaveJobEventWithoutUpdateFails() {
-    saveJobEvent(makeJobUpdateEvent(ROLLING_FORWARD, 123L), makeKey("u2"));
-  }
-
-  @Test(expected = StorageException.class)
-  public void testSaveInstanceEventWithoutUpdateFails() {
-    saveJobInstanceEvent(makeJobInstanceEvent(0, 125L, INSTANCE_UPDATED), makeKey("u1"));
-  }
-
-  @Test
-  public void testSaveJobUpdateStateIgnored() {
-    IJobUpdateKey updateId = makeKey("u1");
-    IJobUpdate update = populateExpected(makeJobUpdate(updateId), ABORTED, 567L, 567L);
-    saveUpdate(update, Optional.of("lock1"));
-
-    // Assert state fields were ignored.
-    assertUpdate(update);
-  }
-
-  @Test
-  public void testSaveJobUpdateWithoutEventFailsSelect() {
-    final IJobUpdateKey updateId = makeKey("u3");
-    storage.write(new MutateWork.NoResult.Quiet() {
-      @Override
-      public void execute(MutableStoreProvider storeProvider) {
-        IJobUpdate update = makeJobUpdate(updateId);
-        storeProvider.getLockStore().saveLock(makeLock(update.getSummary().getJobKey(), "lock1"));
-        storeProvider.getJobUpdateStore().saveJobUpdate(update, Optional.of("lock1"));
-      }
-    });
-    assertEquals(Optional.<IJobUpdateDetails>absent(), getUpdateDetails(updateId));
-  }
-
-  @Test
-  public void testMultipleJobDetails() {
-    IJobUpdateKey updateId1 = makeKey(JobKeys.from("role", "env", "name1"), "u1");
-    IJobUpdateKey updateId2 = makeKey(JobKeys.from("role", "env", "name2"), "u2");
-    IJobUpdateDetails details1 = makeJobDetails(makeJobUpdate(updateId1));
-    IJobUpdateDetails details2 = makeJobDetails(makeJobUpdate(updateId2));
-
-    assertEquals(ImmutableList.<IJobInstanceUpdateEvent>of(), getInstanceEvents(updateId2, 3));
-
-    saveUpdate(details1.getUpdate(), Optional.of("lock1"));
-    saveUpdate(details2.getUpdate(), Optional.of("lock2"));
-
-    details1 = updateJobDetails(populateExpected(details1.getUpdate()), FIRST_EVENT);
-    details2 = updateJobDetails(populateExpected(details2.getUpdate()), FIRST_EVENT);
-    assertEquals(Optional.of(details1), getUpdateDetails(updateId1));
-    assertEquals(Optional.of(details2), getUpdateDetails(updateId2));
-
-    IJobUpdateEvent jEvent11 = makeJobUpdateEvent(ROLLING_FORWARD, 456L);
-    IJobUpdateEvent jEvent12 = makeJobUpdateEvent(ERROR, 457L);
-    IJobInstanceUpdateEvent iEvent11 = makeJobInstanceEvent(1, 451L, INSTANCE_UPDATED);
-    IJobInstanceUpdateEvent iEvent12 = makeJobInstanceEvent(2, 452L, INSTANCE_UPDATING);
-
-    IJobUpdateEvent jEvent21 = makeJobUpdateEvent(ROLL_FORWARD_PAUSED, 567L);
-    IJobUpdateEvent jEvent22 = makeJobUpdateEvent(ABORTED, 568L);
-    IJobInstanceUpdateEvent iEvent21 = makeJobInstanceEvent(3, 561L, INSTANCE_UPDATING);
-    IJobInstanceUpdateEvent iEvent22 = makeJobInstanceEvent(3, 562L, INSTANCE_UPDATED);
-
-    saveJobEvent(jEvent11, updateId1);
-    saveJobEvent(jEvent12, updateId1);
-    saveJobInstanceEvent(iEvent11, updateId1);
-    saveJobInstanceEvent(iEvent12, updateId1);
-
-    saveJobEvent(jEvent21, updateId2);
-    saveJobEvent(jEvent22, updateId2);
-    assertEquals(ImmutableList.<IJobInstanceUpdateEvent>of(), getInstanceEvents(updateId2, 3));
-    saveJobInstanceEvent(iEvent21, updateId2);
-
-    assertEquals(ImmutableList.of(iEvent21), getInstanceEvents(updateId2, 3));
-    saveJobInstanceEvent(iEvent22, updateId2);
-    assertEquals(ImmutableList.of(iEvent21, iEvent22), getInstanceEvents(updateId2, 3));
-
-    details1 = updateJobDetails(
-        populateExpected(details1.getUpdate(), ERROR, CREATED_MS, 457L),
-        ImmutableList.of(FIRST_EVENT, jEvent11, jEvent12), ImmutableList.of(iEvent11, iEvent12));
-
-    details2 = updateJobDetails(
-        populateExpected(details2.getUpdate(), ABORTED, CREATED_MS, 568L),
-        ImmutableList.of(FIRST_EVENT, jEvent21, jEvent22), ImmutableList.of(iEvent21, iEvent22));
-
-    assertEquals(Optional.of(details1), getUpdateDetails(updateId1));
-    assertEquals(Optional.of(details2), getUpdateDetails(updateId2));
-
-    assertEquals(
-        ImmutableSet.of(
-            new StoredJobUpdateDetails(details1.newBuilder(), "lock1"),
-            new StoredJobUpdateDetails(details2.newBuilder(), "lock2")),
-        getAllUpdateDetails());
-
-    assertEquals(
-        ImmutableList.of(getUpdateDetails(updateId2).get(), getUpdateDetails(updateId1).get()),
-        queryDetails(new JobUpdateQuery().setRole("role")));
-  }
-
-  @Test
-  public void testTruncateJobUpdates() {
-    IJobUpdateKey updateId = makeKey("u5");
-    IJobUpdate update = makeJobUpdate(updateId);
-    IJobInstanceUpdateEvent instanceEvent = IJobInstanceUpdateEvent.build(
-        new JobInstanceUpdateEvent(0, 125L, INSTANCE_ROLLBACK_FAILED));
-
-    saveUpdate(update, Optional.of("lock"));
-    saveJobEvent(makeJobUpdateEvent(ROLLING_FORWARD, 123L), updateId);
-    saveJobInstanceEvent(instanceEvent, updateId);
-    assertEquals(
-        populateExpected(update, ROLLING_FORWARD, CREATED_MS, 125L),
-        getUpdate(updateId).get());
-    assertEquals(2, getUpdateDetails(updateId).get().getUpdateEvents().size());
-    assertEquals(1, getUpdateDetails(updateId).get().getInstanceEvents().size());
-
-    truncateUpdates();
-    assertEquals(Optional.<IJobUpdateDetails>absent(), getUpdateDetails(updateId));
-  }
-
-  @Test
-  public void testPruneHistory() {
-    IJobUpdateKey updateId1 = makeKey("u11");
-    IJobUpdateKey updateId2 = makeKey("u12");
-    IJobUpdateKey updateId3 = makeKey("u13");
-    IJobUpdateKey updateId4 = makeKey("u14");
-    IJobKey job2 = JobKeys.from("testRole2", "testEnv2", "job2");
-    IJobUpdateKey updateId5 = makeKey(job2, "u15");
-    IJobUpdateKey updateId6 = makeKey(job2, "u16");
-    IJobUpdateKey updateId7 = makeKey(job2, "u17");
-
-    IJobUpdate update1 = makeJobUpdate(updateId1);
-    IJobUpdate update2 = makeJobUpdate(updateId2);
-    IJobUpdate update3 = makeJobUpdate(updateId3);
-    IJobUpdate update4 = makeJobUpdate(updateId4);
-    IJobUpdate update5 = makeJobUpdate(updateId5);
-    IJobUpdate update6 = makeJobUpdate(updateId6);
-    IJobUpdate update7 = makeJobUpdate(updateId7);
-
-    IJobUpdateEvent updateEvent1 = makeJobUpdateEvent(ROLLING_BACK, 123L);
-    IJobUpdateEvent updateEvent2 = makeJobUpdateEvent(ABORTED, 124L);
-    IJobUpdateEvent updateEvent3 = makeJobUpdateEvent(ROLLED_BACK, 125L);
-    IJobUpdateEvent updateEvent4 = makeJobUpdateEvent(FAILED, 126L);
-    IJobUpdateEvent updateEvent5 = makeJobUpdateEvent(ERROR, 123L);
-    IJobUpdateEvent updateEvent6 = makeJobUpdateEvent(FAILED, 125L);
-    IJobUpdateEvent updateEvent7 = makeJobUpdateEvent(ROLLING_FORWARD, 126L);
-
-    update1 = populateExpected(
-        saveUpdateNoEvent(update1, Optional.of("lock1")), ROLLING_BACK, 123L, 123L);
-    update2 = populateExpected(
-        saveUpdateNoEvent(update2, Optional.<String>absent()), ABORTED, 124L, 124L);
-    update3 = populateExpected(
-        saveUpdateNoEvent(update3, Optional.<String>absent()), ROLLED_BACK, 125L, 125L);
-    update4 = populateExpected(
-        saveUpdateNoEvent(update4, Optional.<String>absent()), FAILED, 126L, 126L);
-    update5 = populateExpected(
-        saveUpdateNoEvent(update5, Optional.<String>absent()), ERROR, 123L, 123L);
-    update6 = populateExpected(
-        saveUpdateNoEvent(update6, Optional.<String>absent()), FAILED, 125L, 125L);
-    update7 = populateExpected(
-        saveUpdateNoEvent(update7, Optional.of("lock2")), ROLLING_FORWARD, 126L, 126L);
-
-    saveJobEvent(updateEvent1, updateId1);
-    saveJobEvent(updateEvent2, updateId2);
-    saveJobEvent(updateEvent3, updateId3);
-    saveJobEvent(updateEvent4, updateId4);
-    saveJobEvent(updateEvent5, updateId5);
-    saveJobEvent(updateEvent6, updateId6);
-    saveJobEvent(updateEvent7, updateId7);
-
-    assertEquals(update1, getUpdate(updateId1).get());
-    assertEquals(update2, getUpdate(updateId2).get());
-    assertEquals(update3, getUpdate(updateId3).get());
-    assertEquals(update4, getUpdate(updateId4).get());
-    assertEquals(update5, getUpdate(updateId5).get());
-    assertEquals(update6, getUpdate(updateId6).get());
-    assertEquals(update7, getUpdate(updateId7).get());
-
-    long pruningThreshold = 120L;
-
-    // No updates pruned.
-    assertEquals(ImmutableSet.<IJobUpdateKey>of(), pruneHistory(3, pruningThreshold));
-    assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
-    assertEquals(Optional.of(update6), getUpdate(updateId6));
-    assertEquals(Optional.of(update5), getUpdate(updateId5));
-
-    assertEquals(Optional.of(update4), getUpdate(updateId4));
-    assertEquals(Optional.of(update3), getUpdate(updateId3));
-    assertEquals(Optional.of(update2), getUpdate(updateId2));
-    assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
-
-    assertEquals(ImmutableSet.of(updateId2), pruneHistory(2, pruningThreshold));
-    // No updates pruned.
-    assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
-    assertEquals(Optional.of(update6), getUpdate(updateId6));
-    assertEquals(Optional.of(update5), getUpdate(updateId5));
-
-    // 1 update pruned.
-    assertEquals(Optional.of(update4), getUpdate(updateId4));
-    assertEquals(Optional.of(update3), getUpdate(updateId3));
-    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId2));
-    assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
-
-    assertEquals(ImmutableSet.of(updateId5, updateId3), pruneHistory(1, pruningThreshold));
-    // 1 update pruned.
-    assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
-    assertEquals(Optional.of(update6), getUpdate(updateId6));
-    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId5));
-
-    // 2 updates pruned.
-    assertEquals(Optional.of(update4), getUpdate(updateId4));
-    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId3));
-    assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
-
-    // The oldest update is pruned.
-    assertEquals(ImmutableSet.of(updateId6), pruneHistory(1, 126L));
-    assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
-    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId6));
-
-    assertEquals(Optional.of(update4), getUpdate(updateId4));
-    assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
-
-    // Nothing survives the 0 per job count.
-    assertEquals(ImmutableSet.of(updateId4), pruneHistory(0, pruningThreshold));
-    assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
-
-    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId4));
-    assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
-  }
-
-  @Test(expected = StorageException.class)
-  public void testSaveUpdateWithoutLock() {
-    final IJobUpdate update = makeJobUpdate(makeKey("updateId"));
-    storage.write(new MutateWork.NoResult.Quiet() {
-      @Override
-      public void execute(MutableStoreProvider storeProvider) {
-        storeProvider.getJobUpdateStore().saveJobUpdate(update, Optional.of("lock"));
-      }
-    });
-  }
-
-  @Test(expected = StorageException.class)
-  public void testSaveTwoUpdatesForOneJob() {
-    final IJobUpdate update = makeJobUpdate(makeKey("updateId"));
-    saveUpdate(update, Optional.of("lock1"));
-    saveUpdate(update, Optional.of("lock2"));
-  }
-
-  @Test(expected = StorageException.class)
-  public void testSaveTwoUpdatesSameJobKey() {
-    final IJobUpdate update1 = makeJobUpdate(makeKey("update1"));
-    final IJobUpdate update2 = makeJobUpdate(makeKey("update2"));
-    saveUpdate(update1, Optional.of("lock1"));
-    saveUpdate(update2, Optional.of("lock1"));
-  }
-
-  @Test
-  public void testLockCleared() {
-    final IJobUpdate update = makeJobUpdate(makeKey("update1"));
-    saveUpdate(update, Optional.of("lock1"));
-
-    removeLock(update, "lock1");
-
-    assertEquals(
-        Optional.of(updateJobDetails(populateExpected(update), FIRST_EVENT)),
-        getUpdateDetails(makeKey("update1")));
-    assertEquals(
-        ImmutableSet.of(
-            new StoredJobUpdateDetails(
-                updateJobDetails(populateExpected(update), FIRST_EVENT).newBuilder(),
-                null)),
-        getAllUpdateDetails());
-
-    assertEquals(
-        ImmutableList.of(populateExpected(update).getSummary()),
-        getSummaries(new JobUpdateQuery().setKey(UPDATE1.newBuilder())));
-
-    // If the lock has been released for this job, we can start another update.
-    saveUpdate(makeJobUpdate(makeKey("update2")), Optional.of("lock2"));
-  }
-
-  private static final Optional<String> NO_TOKEN = Optional.absent();
-
-  @Test
-  public void testGetLockToken() {
-    storage.write(new MutateWork.NoResult.Quiet() {
-      @Override
-      public void execute(MutableStoreProvider storeProvider) {
-        final IJobUpdate update1 = makeJobUpdate(UPDATE1);
-        final IJobUpdate update2 = makeJobUpdate(UPDATE2);
-        saveUpdate(update1, Optional.of("lock1"));
-        assertEquals(
-            Optional.of("lock1"),
-            storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
-        assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
-
-        saveUpdate(update2, Optional.of("lock2"));
-        assertEquals(
-            Optional.of("lock1"),
-            storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
-        assertEquals(
-            Optional.of("lock2"),
-            storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
-
-        storeProvider.getLockStore().removeLock(
-            makeLock(update1.getSummary().getJobKey(), "lock1").getKey());
-        assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
-        assertEquals(
-            Optional.of("lock2"),
-            storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
-
-        storeProvider.getLockStore().removeLock(
-            makeLock(update2.getSummary().getJobKey(), "lock2").getKey());
-        assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
-        assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
-      }
-    });
-  }
-
-  @Test
-  public void testGetSummaries() {
-    String role1 = "role1";
-    IJobKey job1 = JobKeys.from(role1, "env", "name1");
-    IJobKey job2 = JobKeys.from(role1, "env", "name2");
-    IJobKey job3 = JobKeys.from(role1, "env", "name3");
-    IJobKey job4 = JobKeys.from(role1, "env", "name4");
-    IJobKey job5 = JobKeys.from("role", "env", "name5");
-    IJobUpdateSummary s1 =
-        saveSummary(makeKey(job1, "u1"), 1230L, ROLLED_BACK, "user", Optional.of("lock1"));
-    IJobUpdateSummary s2 =
-        saveSummary(makeKey(job2, "u2"), 1231L, ABORTED, "user", Optional.of("lock2"));
-    IJobUpdateSummary s3 =
-        saveSummary(makeKey(job3, "u3"), 1239L, ERROR, "user2", Optional.of("lock3"));
-    IJobUpdateSummary s4 =
-        saveSummary(makeKey(job4, "u4"), 1234L, ROLL_BACK_PAUSED, "user3", Optional.of("lock4"));
-    IJobUpdateSummary s5 =
-        saveSummary(makeKey(job5, "u5"), 1235L, ROLLING_FORWARD, "user4", Optional.of("lock5"));
-
-    // Test empty query returns all.
-    assertEquals(ImmutableList.of(s3, s5, s4, s2, s1), getSummaries(new JobUpdateQuery()));
-
-    // Test query by updateId.
-    assertEquals(
-        ImmutableList.of(s1),
-        getSummaries(new JobUpdateQuery().setKey(new JobUpdateKey(job1.newBuilder(), "u1"))));
-
-    // Test query by role.
-    assertEquals(
-        ImmutableList.of(s3, s4, s2, s1),
-        getSummaries(new JobUpdateQuery().setRole(role1)));
-
-    // Test query by job key.
-    assertEquals(
-        ImmutableList.of(s5),
-        getSummaries(new JobUpdateQuery().setJobKey(job5.newBuilder())));
-
-    // Test querying by update key.
-    assertEquals(
-        ImmutableList.of(s5),
-        getSummaries(
-            new JobUpdateQuery().setKey(new JobUpdateKey(job5.newBuilder(), s5.getUpdateId()))));
-
-    // Test querying by incorrect update keys.
-    assertEquals(
-        ImmutableList.<IJobUpdateSummary>of(),
-        getSummaries(
-            new JobUpdateQuery().setKey(new JobUpdateKey(job5.newBuilder(), s4.getUpdateId()))));
-    assertEquals(
-        ImmutableList.<IJobUpdateSummary>of(),
-        getSummaries(
-            new JobUpdateQuery().setKey(new JobUpdateKey(job4.newBuilder(), s5.getUpdateId()))));
-
-    // Test query by user.
-    assertEquals(ImmutableList.of(s2, s1), getSummaries(new JobUpdateQuery().setUser("user")));
-
-    // Test query by one status.
-    assertEquals(ImmutableList.of(s3), getSummaries(new JobUpdateQuery().setUpdateStatuses(
-        ImmutableSet.of(ERROR))));
-
-    // Test query by multiple statuses.
-    assertEquals(ImmutableList.of(s3, s2, s1), getSummaries(new JobUpdateQuery().setUpdateStatuses(
-        ImmutableSet.of(ERROR, ABORTED, ROLLED_BACK))));
-
-    // Test query by empty statuses.
-    assertEquals(
-        ImmutableList.of(s3, s5, s4, s2, s1),
-        getSummaries(new JobUpdateQuery().setUpdateStatuses(ImmutableSet.<JobUpdateStatus>of())));
-
-    // Test paging.
-    assertEquals(
-        ImmutableList.of(s3, s5),
-        getSummaries(new JobUpdateQuery().setLimit(2).setOffset(0)));
-    assertEquals(
-        ImmutableList.of(s4, s2),
-        getSummaries(new JobUpdateQuery().setLimit(2).setOffset(2)));
-    assertEquals(
-        ImmutableList.of(s1),
-        getSummaries(new JobUpdateQuery().setLimit(2).setOffset(4)));
-
-    // Test no match.
-    assertEquals(
-        ImmutableList.<IJobUpdateSummary>of(),
-        getSummaries(new JobUpdateQuery().setRole("no_match")));
-  }
-
-  @Test
-  public void testQueryDetails() {
-    IJobKey jobKey1 = JobKeys.from("role1", "env", "name1");
-    IJobUpdateKey updateId1 = makeKey(jobKey1, "u1");
-    IJobKey jobKey2 = JobKeys.from("role2", "env", "name2");
-    IJobUpdateKey updateId2 = makeKey(jobKey2, "u2");
-
-    IJobUpdate update1 = makeJobUpdate(updateId1);
-    IJobUpdate update2 = makeJobUpdate(updateId2);
-
-    assertEquals(ImmutableList.<IJobInstanceUpdateEvent>of(), getInstanceEvents(updateId2, 3));
-
-    saveUpdate(update1, Optional.of("lock1"));
-    saveUpdate(update2, Optional.of("lock2"));
-
-    updateJobDetails(populateExpected(update1), FIRST_EVENT);
-    updateJobDetails(populateExpected(update2), FIRST_EVENT);
-
-    IJobUpdateEvent jEvent11 = makeJobUpdateEvent(ROLLING_BACK, 450L);
-    IJobUpdateEvent jEvent12 = makeJobUpdateEvent(ROLLED_BACK, 500L);
-    IJobInstanceUpdateEvent iEvent11 = makeJobInstanceEvent(1, 451L, INSTANCE_ROLLING_BACK);
-    IJobInstanceUpdateEvent iEvent12 = makeJobInstanceEvent(2, 458L, INSTANCE_ROLLED_BACK);
-
-    IJobUpdateEvent jEvent21 = makeJobUpdateEvent(ROLL_FORWARD_PAUSED, 550L);
-    IJobUpdateEvent jEvent22 = makeJobUpdateEvent(ABORTED, 600L);
-    IJobInstanceUpdateEvent iEvent21 = makeJobInstanceEvent(3, 561L, INSTANCE_UPDATING);
-    IJobInstanceUpdateEvent iEvent22 = makeJobInstanceEvent(3, 570L, INSTANCE_UPDATED);
-
-    saveJobEvent(jEvent11, updateId1);
-    saveJobEvent(jEvent12, updateId1);
-    saveJobInstanceEvent(iEvent11, updateId1);
-    saveJobInstanceEvent(iEvent12, updateId1);
-
-    saveJobEvent(jEvent21, updateId2);
-    saveJobEvent(jEvent22, updateId2);
-
-    saveJobInstanceEvent(iEvent21, updateId2);
-    saveJobInstanceEvent(iEvent22, updateId2);
-
-    IJobUpdateDetails details1 = getUpdateDetails(updateId1).get();
-    IJobUpdateDetails details2 = getUpdateDetails(updateId2).get();
-
-    // Test empty query returns all.
-    assertEquals(ImmutableList.of(details2, details1), queryDetails(new JobUpdateQuery()));
-
-    // Test query by update ID.
-    assertEquals(
-        ImmutableList.of(details1),
-        queryDetails(new JobUpdateQuery().setKey(updateId1.newBuilder())));
-
-    // Test query by role.
-    assertEquals(
-        ImmutableList.of(details2),
-        queryDetails(new JobUpdateQuery().setRole(jobKey2.getRole())));
-
-    // Test query by job key.
-    assertEquals(
-        ImmutableList.of(details2),
-        queryDetails(new JobUpdateQuery().setJobKey(jobKey2.newBuilder())));
-
-    // Test query by status.
-    assertEquals(
-        ImmutableList.of(details2),
-        queryDetails(new JobUpdateQuery().setUpdateStatuses(ImmutableSet.of(ABORTED))));
-
-    // Test no match.
-    assertEquals(
-        ImmutableList.<IJobUpdateDetails>of(),
-        queryDetails(new JobUpdateQuery().setRole("no match")));
-  }
-
-  private static IJobUpdateKey makeKey(String id) {
-    return makeKey(JOB, id);
-  }
-
-  private static IJobUpdateKey makeKey(IJobKey job, String id) {
-    return IJobUpdateKey.build(new JobUpdateKey(job.newBuilder(), id));
-  }
-
-  private void assertUpdate(IJobUpdate expected) {
-    IJobUpdateKey key = expected.getSummary().getKey();
-    assertEquals(populateExpected(expected), getUpdate(key).get());
-    assertEquals(getUpdate(key).get(), getUpdateDetails(key).get().getUpdate());
-    assertEquals(getUpdateInstructions(key).get(), expected.getInstructions());
-  }
-
-  private Optional<IJobUpdate> getUpdate(final IJobUpdateKey key) {
-    return storage.read(new Quiet<Optional<IJobUpdate>>() {
-      @Override
-      public Optional<IJobUpdate> apply(Storage.StoreProvider storeProvider) {
-        return storeProvider.getJobUpdateStore().fetchJobUpdate(key);
-      }
-    });
-  }
-
-  private List<IJobInstanceUpdateEvent> getInstanceEvents(final IJobUpdateKey key, final int id) {
-    return storage.read(new Quiet<List<IJobInstanceUpdateEvent>>() {
-      @Override
-      public List<IJobInstanceUpdateEvent> apply(Storage.StoreProvider storeProvider) {
-        return storeProvider.getJobUpdateStore().fetchInstanceEvents(key, id);
-      }
-    });
-  }
-
-  private Optional<IJobUpdateInstructions> getUpdateInstructions(final IJobUpdateKey key) {
-    return storage.read(new Quiet<Optional<IJobUpdateInstructions>>() {
-      @Override
-      public Optional<IJobUpdateInstructions> apply(Storage.StoreProvider storeProvider) {
-        return storeProvider.getJobUpdateStore().fetchJobUpdateInstructions(key);
-      }
-    });
-  }
-
-  private Optional<IJobUpdateDetails> getUpdateDetails(final IJobUpdateKey key) {
-    return storage.read(new Quiet<Optional<IJobUpdateDetails>>() {
-      @Override
-      public Optional<IJobUpdateDetails> apply(Storage.StoreProvider storeProvider) {
-        return storeProvider.getJobUpdateStore().fetchJobUpdateDetails(key);
-      }
-    });
-  }
-
-  private Set<StoredJobUpdateDetails> getAllUpdateDetails() {
-    return storage.read(new Quiet<Set<StoredJobUpdateDetails>>() {
-      @Override
-      public Set<StoredJobUpdateDetails> apply(Storage.StoreProvider storeProvider) {
-        return storeProvider.getJobUpdateStore().fetchAllJobUpdateDetails();
-      }
-    });
-  }
-
-  private List<IJobUpdateDetails> queryDetails(final JobUpdateQuery query) {
-    return storage.read(new Quiet<List<IJobUpdateDetails>>() {
-      @Override
-      public List<IJobUpdateDetails> apply(Storage.StoreProvider storeProvider) {
-        return storeProvider.getJobUpdateStore().fetchJobUpdateDetails(
-            IJobUpdateQuery.build(query));
-      }
-    });
-  }
-
-  private List<IJobUpdateSummary> getSummaries(final JobUpdateQuery query) {
-    return storage.read(new Quiet<List<IJobUpdateSummary>>() {
-      @Override
-      public List<IJobUpdateSummary> apply(Storage.StoreProvider storeProvider) {
-        return storeProvider.getJobUpdateStore().fetchJobUpdateSummaries(
-            IJobUpdateQuery.build(query));
-      }
-    });
-  }
-
-  private static ILock makeLock(IJobKey jobKey, String lockToken) {
-    return ILock.build(new Lock()
-        .setKey(LockKey.job(jobKey.newBuilder()))
-        .setToken(lockToken)
-        .setTimestampMs(100)
-        .setUser("fake user"));
-  }
-
-  private IJobUpdate saveUpdate(final IJobUpdate update, final Optional<String> lockToken) {
-    storage.write(new MutateWork.NoResult.Quiet() {
-      @Override
-      public void execute(MutableStoreProvider storeProvider) {
-        if (lockToken.isPresent()) {
-          storeProvider.getLockStore().saveLock(
-              makeLock(update.getSummary().getJobKey(), lockToken.get()));
-        }
-        storeProvider.getJobUpdateStore().saveJobUpdate(update, lockToken);
-        storeProvider.getJobUpdateStore().saveJobUpdateEvent(
-            update.getSummary().getKey(),
-            FIRST_EVENT);
-      }
-    });
-
-    return update;
-  }
-
-  private IJobUpdate saveUpdateNoEvent(final IJobUpdate update, final Optional<String> lockToken) {
-    storage.write(new MutateWork.NoResult.Quiet() {
-      @Override
-      public void execute(MutableStoreProvider storeProvider) {
-        if (lockToken.isPresent()) {
-          storeProvider.getLockStore().saveLock(
-              makeLock(update.getSummary().getJobKey(), lockToken.get()));
-        }
-        storeProvider.getJobUpdateStore().saveJobUpdate(update, lockToken);
-      }
-    });
-
-    return update;
-  }
-
-  private void saveJobEvent(final IJobUpdateEvent event, final IJobUpdateKey key) {
-    storage.write(new MutateWork.NoResult.Quiet() {
-      @Override
-      public void execute(MutableStoreProvider storeProvider) {
-        storeProvider.getJobUpdateStore().saveJobUpdateEvent(key, event);
-      }
-    });
-  }
-
-  private void saveJobInstanceEvent(final IJobInstanceUpdateEvent event, final IJobUpdateKey key) {
-    storage.write(new MutateWork.NoResult.Quiet() {
-      @Override
-      public void execute(MutableStoreProvider storeProvider) {
-        storeProvider.getJobUpdateStore().saveJobInstanceUpdateEvent(key, event);
-      }
-    });
-  }
-
-  private void truncateUpdates() {
-    storage.write(new MutateWork.NoResult.Quiet() {
-      @Override
-      public void execute(MutableStoreProvider storeProvider) {
-        storeProvider.getJobUpdateStore().deleteAllUpdatesAndEvents();
-      }
-    });
-  }
-
-  private Set<IJobUpdateKey> pruneHistory(final int retainCount, final long pruningThresholdMs) {
-    return storage.write(new MutateWork.Quiet<Set<IJobUpdateKey>>() {
-      @Override
-      public Set<IJobUpdateKey> apply(MutableStoreProvider storeProvider) {
-        return storeProvider.getJobUpdateStore().pruneHistory(retainCount, pruningThresholdMs);
-      }
-    });
-  }
-
-  private void removeLock(final IJobUpdate update, final String lockToken) {
-    storage.write(new MutateWork.NoResult.Quiet() {
-      @Override
-      public void execute(MutableStoreProvider storeProvider) {
-        storeProvider.getLockStore().removeLock(
-            makeLock(update.getSummary().getJobKey(), lockToken).getKey());
-      }
-    });
-  }
-
-  private IJobUpdate populateExpected(IJobUpdate update) {
-    return populateExpected(update, ROLLING_FORWARD, CREATED_MS, CREATED_MS);
-  }
-
-  private IJobUpdate populateExpected(
-      IJobUpdate update,
-      JobUpdateStatus status,
-      long createdMs,
-      long lastMs) {
-
-    JobUpdateState state = new JobUpdateState()
-        .setCreatedTimestampMs(createdMs)
-        .setLastModifiedTimestampMs(lastMs)
-        .setStatus(status);
-    JobUpdate builder = update.newBuilder();
-    builder.getSummary().setState(state);
-    return IJobUpdate.build(builder);
-  }
-
-  private static IJobUpdateEvent makeJobUpdateEvent(JobUpdateStatus status, long timestampMs) {
-    return IJobUpdateEvent.build(
-        new JobUpdateEvent(status, timestampMs)
-            .setUser("user")
-            .setMessage("message"));
-  }
-
-  private IJobInstanceUpdateEvent makeJobInstanceEvent(
-      int instanceId,
-      long timestampMs,
-      JobUpdateAction action) {
-
-    return IJobInstanceUpdateEvent.build(
-        new JobInstanceUpdateEvent(instanceId, timestampMs, action));
-  }
-
-  private IJobUpdateDetails makeJobDetails(IJobUpdate update) {
-    return updateJobDetails(
-        update,
-        ImmutableList.of(FIRST_EVENT),
-        ImmutableList.<IJobInstanceUpdateEvent>of());
-  }
-
-  private IJobUpdateDetails updateJobDetails(IJobUpdate update, IJobUpdateEvent event) {
-    return updateJobDetails(
-        update,
-        ImmutableList.of(event),
-        ImmutableList.<IJobInstanceUpdateEvent>of());
-  }
-
-  private IJobUpdateDetails updateJobDetails(
-      IJobUpdate update,
-      List<IJobUpdateEvent> jobEvents,
-      List<IJobInstanceUpdateEvent> instanceEvents) {
-
-    return IJobUpdateDetails.build(new JobUpdateDetails()
-        .setUpdate(update.newBuilder())
-        .setUpdateEvents(IJobUpdateEvent.toBuildersList(jobEvents))
-        .setInstanceEvents(IJobInstanceUpdateEvent.toBuildersList(instanceEvents)));
-  }
-
-  private IJobUpdateSummary makeSummary(IJobUpdateKey key, String user) {
-    return IJobUpdateSummary.build(new JobUpdateSummary()
-        .setKey(key.newBuilder())
-        .setUpdateId(key.getId())
-        .setJobKey(key.getJob().newBuilder())
-        .setUser(user));
-  }
-
-  private IJobUpdateSummary saveSummary(
-      IJobUpdateKey key,
-      Long modifiedTimestampMs,
-      JobUpdateStatus status,
-      String user,
-      Optional<String> lockToken) {
-
-    IJobUpdateSummary summary = IJobUpdateSummary.build(new JobUpdateSummary()
-        .setKey(key.newBuilder())
-        .setUpdateId(key.getId())
-        .setJobKey(key.getJob().newBuilder())
-        .setUser(user));
-
-    IJobUpdate update = makeJobUpdate(summary);
-    saveUpdate(update, lockToken);
-    saveJobEvent(makeJobUpdateEvent(status, modifiedTimestampMs), key);
-    return populateExpected(update, status, CREATED_MS, modifiedTimestampMs).getSummary();
-  }
-
-  private IJobUpdate makeJobUpdate(IJobUpdateSummary summary) {
-    return IJobUpdate.build(makeJobUpdate().newBuilder().setSummary(summary.newBuilder()));
-  }
-
-  private IJobUpdate makeJobUpdate(IJobUpdateKey key) {
-    return IJobUpdate.build(makeJobUpdate().newBuilder()
-        .setSummary(makeSummary(key, "user").newBuilder()));
-  }
-
-  private IJobUpdate makeJobUpdate() {
-    return IJobUpdate.build(new JobUpdate()
-        .setInstructions(makeJobUpdateInstructions().newBuilder()));
-  }
-
-  private IJobUpdateInstructions makeJobUpdateInstructions() {
-    return IJobUpdateInstructions.build(new JobUpdateInstructions()
-        .setDesiredState(new InstanceTaskConfig()
-            .setTask(makeTaskConfig())
-            .setInstances(ImmutableSet.of(new Range(0, 7), new Range(8, 9))))
-        .setInitialState(ImmutableSet.of(
-            new InstanceTaskConfig()
-                .setInstances(ImmutableSet.of(new Range(0, 1), new Range(2, 3)))
-                .setTask(makeTaskConfig()),
-            new InstanceTaskConfig()
-                .setInstances(ImmutableSet.of(new Range(4, 5), new Range(6, 7)))
-                .setTask(makeTaskConfig())))
-        .setSettings(new JobUpdateSettings()
-            .setBlockIfNoPulsesAfterMs(500)
-            .setUpdateOnlyTheseInstances(ImmutableSet.of(new Range(0, 0), new Range(3, 5)))));
-  }
-
-  private TaskConfig makeTaskConfig() {
-    return new TaskConfig()
-        .setJobName(JOB.getName())
-        .setEnvironment(JOB.getEnvironment())
-        .setOwner(new Identity(JOB.getRole(), "user"))
-        .setJob(new JobKey("role", "env", "job"))
-        .setIsService(true)
-        .setConstraints(ImmutableSet.of(
-            new Constraint(
-                "name",
-                TaskConstraint.value(new ValueConstraint(true, ImmutableSet.of("x86"))))))
-        .setRequestedPorts(ImmutableSet.of("http"))
-        .setTaskLinks(ImmutableMap.of("key", "url"))
-        .setContactEmail("foo@bar.com")
-        .setExecutorConfig(new ExecutorConfig("name", "data"))
-        .setMetadata(ImmutableSet.of(new Metadata("name", "value")));
-  }
-}

http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/storage/db/DbJobUpdateStoreTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/storage/db/DbJobUpdateStoreTest.java b/src/test/java/org/apache/aurora/scheduler/storage/db/DbJobUpdateStoreTest.java
new file mode 100644
index 0000000..219676f
--- /dev/null
+++ b/src/test/java/org/apache/aurora/scheduler/storage/db/DbJobUpdateStoreTest.java
@@ -0,0 +1,1061 @@
+/**
+ * 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 org.apache.aurora.scheduler.storage.db;
+
+import java.util.List;
+import java.util.Set;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+
+import org.apache.aurora.gen.InstanceTaskConfig;
+import org.apache.aurora.gen.JobInstanceUpdateEvent;
+import org.apache.aurora.gen.JobUpdate;
+import org.apache.aurora.gen.JobUpdateAction;
+import org.apache.aurora.gen.JobUpdateDetails;
+import org.apache.aurora.gen.JobUpdateEvent;
+import org.apache.aurora.gen.JobUpdateInstructions;
+import org.apache.aurora.gen.JobUpdateKey;
+import org.apache.aurora.gen.JobUpdateQuery;
+import org.apache.aurora.gen.JobUpdateSettings;
+import org.apache.aurora.gen.JobUpdateState;
+import org.apache.aurora.gen.JobUpdateStatus;
+import org.apache.aurora.gen.JobUpdateSummary;
+import org.apache.aurora.gen.Lock;
+import org.apache.aurora.gen.LockKey;
+import org.apache.aurora.gen.Range;
+import org.apache.aurora.gen.TaskConfig;
+import org.apache.aurora.gen.storage.StoredJobUpdateDetails;
+import org.apache.aurora.scheduler.base.JobKeys;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
+import org.apache.aurora.scheduler.storage.Storage;
+import org.apache.aurora.scheduler.storage.Storage.MutableStoreProvider;
+import org.apache.aurora.scheduler.storage.Storage.MutateWork;
+import org.apache.aurora.scheduler.storage.Storage.StorageException;
+import org.apache.aurora.scheduler.storage.Storage.Work.Quiet;
+import org.apache.aurora.scheduler.storage.entities.IJobInstanceUpdateEvent;
+import org.apache.aurora.scheduler.storage.entities.IJobKey;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdate;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdateDetails;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdateEvent;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdateInstructions;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdateKey;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdateQuery;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdateSummary;
+import org.apache.aurora.scheduler.storage.entities.ILock;
+import org.apache.aurora.scheduler.storage.testing.StorageEntityUtil;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_ROLLBACK_FAILED;
+import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_ROLLED_BACK;
+import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_ROLLING_BACK;
+import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_UPDATED;
+import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_UPDATING;
+import static org.apache.aurora.gen.JobUpdateStatus.ABORTED;
+import static org.apache.aurora.gen.JobUpdateStatus.ERROR;
+import static org.apache.aurora.gen.JobUpdateStatus.FAILED;
+import static org.apache.aurora.gen.JobUpdateStatus.ROLLED_BACK;
+import static org.apache.aurora.gen.JobUpdateStatus.ROLLING_BACK;
+import static org.apache.aurora.gen.JobUpdateStatus.ROLLING_FORWARD;
+import static org.apache.aurora.gen.JobUpdateStatus.ROLL_BACK_PAUSED;
+import static org.apache.aurora.gen.JobUpdateStatus.ROLL_FORWARD_PAUSED;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class DbJobUpdateStoreTest {
+
+  private static final IJobKey JOB = JobKeys.from("testRole", "testEnv", "job");
+  private static final IJobUpdateKey UPDATE1 =
+      IJobUpdateKey.build(new JobUpdateKey(JOB.newBuilder(), "update1"));
+  private static final IJobUpdateKey UPDATE2 = IJobUpdateKey.build(
+      new JobUpdateKey(JobKeys.from("testRole", "testEnv", "job2").newBuilder(), "update2"));
+  private static final long CREATED_MS = 111L;
+  private static final IJobUpdateEvent FIRST_EVENT =
+      makeJobUpdateEvent(ROLLING_FORWARD, CREATED_MS);
+
+  private Storage storage;
+
+  @Before
+  public void setUp() throws Exception {
+    storage = DbUtil.createStorage();
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    truncateUpdates();
+  }
+
+  @Test
+  public void testSaveJobUpdates() {
+    IJobUpdateKey updateId1 = makeKey(JobKeys.from("role", "env", "name1"), "u1");
+    IJobUpdateKey updateId2 = makeKey(JobKeys.from("role", "env", "name2"), "u2");
+
+    IJobUpdate update1 = makeJobUpdate(updateId1);
+    IJobUpdate update2 = makeJobUpdate(updateId2);
+
+    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId1));
+    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId2));
+
+    StorageEntityUtil.assertFullyPopulated(
+        update1,
+        StorageEntityUtil.getField(JobUpdateSummary.class, "state"),
+        StorageEntityUtil.getField(IJobUpdateSummary.class, "state"),
+        StorageEntityUtil.getField(Range.class, "first"),
+        StorageEntityUtil.getField(Range.class, "last"));
+    saveUpdate(update1, Optional.of("lock1"));
+    assertUpdate(update1);
+
+    saveUpdate(update2, Optional.<String>absent());
+    assertUpdate(update2);
+
+    // Colliding update IDs should be forbidden.
+    IJobUpdate update3 =
+        makeJobUpdate(makeKey(JobKeys.from("role", "env", "name3"), updateId2.getId()));
+    try {
+      saveUpdate(update3, Optional.<String>absent());
+      fail("Update ID collision should not be allowed");
+    } catch (StorageException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void testSaveNullInitialState() {
+    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+    builder.getInstructions().unsetInitialState();
+
+    // Save with null initial state instances.
+    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+
+    builder.getInstructions().setInitialState(ImmutableSet.<InstanceTaskConfig>of());
+    assertUpdate(IJobUpdate.build(builder));
+  }
+
+  @Test
+  public void testSaveNullDesiredState() {
+    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+    builder.getInstructions().unsetDesiredState();
+
+    // Save with null desired state instances.
+    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+
+    assertUpdate(IJobUpdate.build(builder));
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testSaveBothInitialAndDesiredMissingThrows() {
+    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+    builder.getInstructions().unsetInitialState();
+    builder.getInstructions().unsetDesiredState();
+
+    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void testSaveNullInitialStateTaskThrows() {
+    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+    builder.getInstructions().getInitialState().add(
+        new InstanceTaskConfig(null, ImmutableSet.<Range>of()));
+
+    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testSaveEmptyInitialStateRangesThrows() {
+    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+    builder.getInstructions().getInitialState().add(
+        new InstanceTaskConfig(new TaskConfig(), ImmutableSet.<Range>of()));
+
+    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void testSaveNullDesiredStateTaskThrows() {
+    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+    builder.getInstructions().getDesiredState().setTask(null);
+
+    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testSaveEmptyDesiredStateRangesThrows() {
+    JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+    builder.getInstructions().getDesiredState().setInstances(ImmutableSet.<Range>of());
+
+    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+  }
+
+  @Test
+  public void testSaveJobUpdateEmptyInstanceOverrides() {
+    IJobUpdateKey updateId = makeKey("u1");
+
+    IJobUpdate update = makeJobUpdate(updateId);
+    JobUpdate builder = update.newBuilder();
+    builder.getInstructions().getSettings().setUpdateOnlyTheseInstances(ImmutableSet.<Range>of());
+
+    IJobUpdate expected = IJobUpdate.build(builder);
+
+    // Save with empty overrides.
+    saveUpdate(expected, Optional.of("lock"));
+    assertUpdate(expected);
+  }
+
+  @Test
+  public void testSaveJobUpdateNullInstanceOverrides() {
+    IJobUpdateKey updateId = makeKey("u1");
+
+    IJobUpdate update = makeJobUpdate(updateId);
+    JobUpdate builder = update.newBuilder();
+    builder.getInstructions().getSettings().setUpdateOnlyTheseInstances(ImmutableSet.<Range>of());
+
+    IJobUpdate expected = IJobUpdate.build(builder);
+
+    // Save with null overrides.
+    builder.getInstructions().getSettings().setUpdateOnlyTheseInstances(null);
+    saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+    assertUpdate(expected);
+  }
+
+  @Test(expected = StorageException.class)
+  public void testSaveJobUpdateTwiceThrows() {
+    IJobUpdateKey updateId = makeKey("u1");
+    IJobUpdate update = makeJobUpdate(updateId);
+
+    saveUpdate(update, Optional.of("lock1"));
+    saveUpdate(update, Optional.of("lock2"));
+  }
+
+  @Test
+  public void testSaveJobEvents() {
+    IJobUpdateKey updateId = makeKey("u3");
+    IJobUpdate update = makeJobUpdate(updateId);
+    IJobUpdateEvent event1 = makeJobUpdateEvent(ROLLING_FORWARD, 124L);
+    IJobUpdateEvent event2 = makeJobUpdateEvent(ROLL_FORWARD_PAUSED, 125L);
+
+    saveUpdate(update, Optional.of("lock1"));
+    assertUpdate(update);
+    assertEquals(ImmutableList.of(FIRST_EVENT), getUpdateDetails(updateId).get().getUpdateEvents());
+
+    saveJobEvent(event1, updateId);
+    assertEquals(
+        populateExpected(update, ROLLING_FORWARD, CREATED_MS, 124L),
+        getUpdateDetails(updateId).get().getUpdate());
+    assertEquals(event1, getUpdateDetails(updateId).get().getUpdateEvents().get(1));
+
+    saveJobEvent(event2, updateId);
+    assertEquals(
+        populateExpected(update, ROLL_FORWARD_PAUSED, CREATED_MS, 125L),
+        getUpdateDetails(updateId).get().getUpdate());
+    assertEquals(event1, getUpdateDetails(updateId).get().getUpdateEvents().get(1));
+    assertEquals(event2, getUpdateDetails(updateId).get().getUpdateEvents().get(2));
+  }
+
+  @Test
+  public void testSaveInstanceEvents() {
+    IJobUpdateKey updateId = makeKey("u3");
+    IJobUpdate update = makeJobUpdate(updateId);
+    IJobInstanceUpdateEvent event1 = makeJobInstanceEvent(0, 125L, INSTANCE_UPDATED);
+    IJobInstanceUpdateEvent event2 = makeJobInstanceEvent(1, 126L, INSTANCE_ROLLING_BACK);
+
+    saveUpdate(update, Optional.of("lock"));
+    assertUpdate(update);
+    assertEquals(0, getUpdateDetails(updateId).get().getInstanceEvents().size());
+
+    saveJobInstanceEvent(event1, updateId);
+    assertEquals(
+        populateExpected(update, ROLLING_FORWARD, CREATED_MS, 125L),
+        getUpdateDetails(updateId).get().getUpdate());
+    assertEquals(
+        event1,
+        Iterables.getOnlyElement(getUpdateDetails(updateId).get().getInstanceEvents()));
+
+    saveJobInstanceEvent(event2, updateId);
+    assertEquals(
+        populateExpected(update, ROLLING_FORWARD, CREATED_MS, 126L),
+        getUpdateDetails(updateId).get().getUpdate());
+    assertEquals(event1, getUpdateDetails(updateId).get().getInstanceEvents().get(0));
+    assertEquals(event2, getUpdateDetails(updateId).get().getInstanceEvents().get(1));
+  }
+
+  @Test(expected = StorageException.class)
+  public void testSaveJobEventWithoutUpdateFails() {
+    saveJobEvent(makeJobUpdateEvent(ROLLING_FORWARD, 123L), makeKey("u2"));
+  }
+
+  @Test(expected = StorageException.class)
+  public void testSaveInstanceEventWithoutUpdateFails() {
+    saveJobInstanceEvent(makeJobInstanceEvent(0, 125L, INSTANCE_UPDATED), makeKey("u1"));
+  }
+
+  @Test
+  public void testSaveJobUpdateStateIgnored() {
+    IJobUpdateKey updateId = makeKey("u1");
+    IJobUpdate update = populateExpected(makeJobUpdate(updateId), ABORTED, 567L, 567L);
+    saveUpdate(update, Optional.of("lock1"));
+
+    // Assert state fields were ignored.
+    assertUpdate(update);
+  }
+
+  @Test
+  public void testSaveJobUpdateWithoutEventFailsSelect() {
+    final IJobUpdateKey updateId = makeKey("u3");
+    storage.write(new MutateWork.NoResult.Quiet() {
+      @Override
+      public void execute(MutableStoreProvider storeProvider) {
+        IJobUpdate update = makeJobUpdate(updateId);
+        storeProvider.getLockStore().saveLock(makeLock(update.getSummary().getJobKey(), "lock1"));
+        storeProvider.getJobUpdateStore().saveJobUpdate(update, Optional.of("lock1"));
+      }
+    });
+    assertEquals(Optional.<IJobUpdateDetails>absent(), getUpdateDetails(updateId));
+  }
+
+  @Test
+  public void testMultipleJobDetails() {
+    IJobUpdateKey updateId1 = makeKey(JobKeys.from("role", "env", "name1"), "u1");
+    IJobUpdateKey updateId2 = makeKey(JobKeys.from("role", "env", "name2"), "u2");
+    IJobUpdateDetails details1 = makeJobDetails(makeJobUpdate(updateId1));
+    IJobUpdateDetails details2 = makeJobDetails(makeJobUpdate(updateId2));
+
+    assertEquals(ImmutableList.<IJobInstanceUpdateEvent>of(), getInstanceEvents(updateId2, 3));
+
+    saveUpdate(details1.getUpdate(), Optional.of("lock1"));
+    saveUpdate(details2.getUpdate(), Optional.of("lock2"));
+
+    details1 = updateJobDetails(populateExpected(details1.getUpdate()), FIRST_EVENT);
+    details2 = updateJobDetails(populateExpected(details2.getUpdate()), FIRST_EVENT);
+    assertEquals(Optional.of(details1), getUpdateDetails(updateId1));
+    assertEquals(Optional.of(details2), getUpdateDetails(updateId2));
+
+    IJobUpdateEvent jEvent11 = makeJobUpdateEvent(ROLLING_FORWARD, 456L);
+    IJobUpdateEvent jEvent12 = makeJobUpdateEvent(ERROR, 457L);
+    IJobInstanceUpdateEvent iEvent11 = makeJobInstanceEvent(1, 451L, INSTANCE_UPDATED);
+    IJobInstanceUpdateEvent iEvent12 = makeJobInstanceEvent(2, 452L, INSTANCE_UPDATING);
+
+    IJobUpdateEvent jEvent21 = makeJobUpdateEvent(ROLL_FORWARD_PAUSED, 567L);
+    IJobUpdateEvent jEvent22 = makeJobUpdateEvent(ABORTED, 568L);
+    IJobInstanceUpdateEvent iEvent21 = makeJobInstanceEvent(3, 561L, INSTANCE_UPDATING);
+    IJobInstanceUpdateEvent iEvent22 = makeJobInstanceEvent(3, 562L, INSTANCE_UPDATED);
+
+    saveJobEvent(jEvent11, updateId1);
+    saveJobEvent(jEvent12, updateId1);
+    saveJobInstanceEvent(iEvent11, updateId1);
+    saveJobInstanceEvent(iEvent12, updateId1);
+
+    saveJobEvent(jEvent21, updateId2);
+    saveJobEvent(jEvent22, updateId2);
+    assertEquals(ImmutableList.<IJobInstanceUpdateEvent>of(), getInstanceEvents(updateId2, 3));
+    saveJobInstanceEvent(iEvent21, updateId2);
+
+    assertEquals(ImmutableList.of(iEvent21), getInstanceEvents(updateId2, 3));
+    saveJobInstanceEvent(iEvent22, updateId2);
+    assertEquals(ImmutableList.of(iEvent21, iEvent22), getInstanceEvents(updateId2, 3));
+
+    details1 = updateJobDetails(
+        populateExpected(details1.getUpdate(), ERROR, CREATED_MS, 457L),
+        ImmutableList.of(FIRST_EVENT, jEvent11, jEvent12), ImmutableList.of(iEvent11, iEvent12));
+
+    details2 = updateJobDetails(
+        populateExpected(details2.getUpdate(), ABORTED, CREATED_MS, 568L),
+        ImmutableList.of(FIRST_EVENT, jEvent21, jEvent22), ImmutableList.of(iEvent21, iEvent22));
+
+    assertEquals(Optional.of(details1), getUpdateDetails(updateId1));
+    assertEquals(Optional.of(details2), getUpdateDetails(updateId2));
+
+    assertEquals(
+        ImmutableSet.of(
+            new StoredJobUpdateDetails(details1.newBuilder(), "lock1"),
+            new StoredJobUpdateDetails(details2.newBuilder(), "lock2")),
+        getAllUpdateDetails());
+
+    assertEquals(
+        ImmutableList.of(getUpdateDetails(updateId2).get(), getUpdateDetails(updateId1).get()),
+        queryDetails(new JobUpdateQuery().setRole("role")));
+  }
+
+  @Test
+  public void testTruncateJobUpdates() {
+    IJobUpdateKey updateId = makeKey("u5");
+    IJobUpdate update = makeJobUpdate(updateId);
+    IJobInstanceUpdateEvent instanceEvent = IJobInstanceUpdateEvent.build(
+        new JobInstanceUpdateEvent(0, 125L, INSTANCE_ROLLBACK_FAILED));
+
+    saveUpdate(update, Optional.of("lock"));
+    saveJobEvent(makeJobUpdateEvent(ROLLING_FORWARD, 123L), updateId);
+    saveJobInstanceEvent(instanceEvent, updateId);
+    assertEquals(
+        populateExpected(update, ROLLING_FORWARD, CREATED_MS, 125L),
+        getUpdate(updateId).get());
+    assertEquals(2, getUpdateDetails(updateId).get().getUpdateEvents().size());
+    assertEquals(1, getUpdateDetails(updateId).get().getInstanceEvents().size());
+
+    truncateUpdates();
+    assertEquals(Optional.<IJobUpdateDetails>absent(), getUpdateDetails(updateId));
+  }
+
+  @Test
+  public void testPruneHistory() {
+    IJobUpdateKey updateId1 = makeKey("u11");
+    IJobUpdateKey updateId2 = makeKey("u12");
+    IJobUpdateKey updateId3 = makeKey("u13");
+    IJobUpdateKey updateId4 = makeKey("u14");
+    IJobKey job2 = JobKeys.from("testRole2", "testEnv2", "job2");
+    IJobUpdateKey updateId5 = makeKey(job2, "u15");
+    IJobUpdateKey updateId6 = makeKey(job2, "u16");
+    IJobUpdateKey updateId7 = makeKey(job2, "u17");
+
+    IJobUpdate update1 = makeJobUpdate(updateId1);
+    IJobUpdate update2 = makeJobUpdate(updateId2);
+    IJobUpdate update3 = makeJobUpdate(updateId3);
+    IJobUpdate update4 = makeJobUpdate(updateId4);
+    IJobUpdate update5 = makeJobUpdate(updateId5);
+    IJobUpdate update6 = makeJobUpdate(updateId6);
+    IJobUpdate update7 = makeJobUpdate(updateId7);
+
+    IJobUpdateEvent updateEvent1 = makeJobUpdateEvent(ROLLING_BACK, 123L);
+    IJobUpdateEvent updateEvent2 = makeJobUpdateEvent(ABORTED, 124L);
+    IJobUpdateEvent updateEvent3 = makeJobUpdateEvent(ROLLED_BACK, 125L);
+    IJobUpdateEvent updateEvent4 = makeJobUpdateEvent(FAILED, 126L);
+    IJobUpdateEvent updateEvent5 = makeJobUpdateEvent(ERROR, 123L);
+    IJobUpdateEvent updateEvent6 = makeJobUpdateEvent(FAILED, 125L);
+    IJobUpdateEvent updateEvent7 = makeJobUpdateEvent(ROLLING_FORWARD, 126L);
+
+    update1 = populateExpected(
+        saveUpdateNoEvent(update1, Optional.of("lock1")), ROLLING_BACK, 123L, 123L);
+    update2 = populateExpected(
+        saveUpdateNoEvent(update2, Optional.<String>absent()), ABORTED, 124L, 124L);
+    update3 = populateExpected(
+        saveUpdateNoEvent(update3, Optional.<String>absent()), ROLLED_BACK, 125L, 125L);
+    update4 = populateExpected(
+        saveUpdateNoEvent(update4, Optional.<String>absent()), FAILED, 126L, 126L);
+    update5 = populateExpected(
+        saveUpdateNoEvent(update5, Optional.<String>absent()), ERROR, 123L, 123L);
+    update6 = populateExpected(
+        saveUpdateNoEvent(update6, Optional.<String>absent()), FAILED, 125L, 125L);
+    update7 = populateExpected(
+        saveUpdateNoEvent(update7, Optional.of("lock2")), ROLLING_FORWARD, 126L, 126L);
+
+    saveJobEvent(updateEvent1, updateId1);
+    saveJobEvent(updateEvent2, updateId2);
+    saveJobEvent(updateEvent3, updateId3);
+    saveJobEvent(updateEvent4, updateId4);
+    saveJobEvent(updateEvent5, updateId5);
+    saveJobEvent(updateEvent6, updateId6);
+    saveJobEvent(updateEvent7, updateId7);
+
+    assertEquals(update1, getUpdate(updateId1).get());
+    assertEquals(update2, getUpdate(updateId2).get());
+    assertEquals(update3, getUpdate(updateId3).get());
+    assertEquals(update4, getUpdate(updateId4).get());
+    assertEquals(update5, getUpdate(updateId5).get());
+    assertEquals(update6, getUpdate(updateId6).get());
+    assertEquals(update7, getUpdate(updateId7).get());
+
+    long pruningThreshold = 120L;
+
+    // No updates pruned.
+    assertEquals(ImmutableSet.<IJobUpdateKey>of(), pruneHistory(3, pruningThreshold));
+    assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
+    assertEquals(Optional.of(update6), getUpdate(updateId6));
+    assertEquals(Optional.of(update5), getUpdate(updateId5));
+
+    assertEquals(Optional.of(update4), getUpdate(updateId4));
+    assertEquals(Optional.of(update3), getUpdate(updateId3));
+    assertEquals(Optional.of(update2), getUpdate(updateId2));
+    assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
+
+    assertEquals(ImmutableSet.of(updateId2), pruneHistory(2, pruningThreshold));
+    // No updates pruned.
+    assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
+    assertEquals(Optional.of(update6), getUpdate(updateId6));
+    assertEquals(Optional.of(update5), getUpdate(updateId5));
+
+    // 1 update pruned.
+    assertEquals(Optional.of(update4), getUpdate(updateId4));
+    assertEquals(Optional.of(update3), getUpdate(updateId3));
+    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId2));
+    assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
+
+    assertEquals(ImmutableSet.of(updateId5, updateId3), pruneHistory(1, pruningThreshold));
+    // 1 update pruned.
+    assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
+    assertEquals(Optional.of(update6), getUpdate(updateId6));
+    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId5));
+
+    // 2 updates pruned.
+    assertEquals(Optional.of(update4), getUpdate(updateId4));
+    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId3));
+    assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
+
+    // The oldest update is pruned.
+    assertEquals(ImmutableSet.of(updateId6), pruneHistory(1, 126L));
+    assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
+    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId6));
+
+    assertEquals(Optional.of(update4), getUpdate(updateId4));
+    assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
+
+    // Nothing survives the 0 per job count.
+    assertEquals(ImmutableSet.of(updateId4), pruneHistory(0, pruningThreshold));
+    assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
+
+    assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId4));
+    assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
+  }
+
+  @Test(expected = StorageException.class)
+  public void testSaveUpdateWithoutLock() {
+    final IJobUpdate update = makeJobUpdate(makeKey("updateId"));
+    storage.write(new MutateWork.NoResult.Quiet() {
+      @Override
+      public void execute(MutableStoreProvider storeProvider) {
+        storeProvider.getJobUpdateStore().saveJobUpdate(update, Optional.of("lock"));
+      }
+    });
+  }
+
+  @Test(expected = StorageException.class)
+  public void testSaveTwoUpdatesForOneJob() {
+    final IJobUpdate update = makeJobUpdate(makeKey("updateId"));
+    saveUpdate(update, Optional.of("lock1"));
+    saveUpdate(update, Optional.of("lock2"));
+  }
+
+  @Test(expected = StorageException.class)
+  public void testSaveTwoUpdatesSameJobKey() {
+    final IJobUpdate update1 = makeJobUpdate(makeKey("update1"));
+    final IJobUpdate update2 = makeJobUpdate(makeKey("update2"));
+    saveUpdate(update1, Optional.of("lock1"));
+    saveUpdate(update2, Optional.of("lock1"));
+  }
+
+  @Test
+  public void testLockCleared() {
+    final IJobUpdate update = makeJobUpdate(makeKey("update1"));
+    saveUpdate(update, Optional.of("lock1"));
+
+    removeLock(update, "lock1");
+
+    assertEquals(
+        Optional.of(updateJobDetails(populateExpected(update), FIRST_EVENT)),
+        getUpdateDetails(makeKey("update1")));
+    assertEquals(
+        ImmutableSet.of(
+            new StoredJobUpdateDetails(
+                updateJobDetails(populateExpected(update), FIRST_EVENT).newBuilder(),
+                null)),
+        getAllUpdateDetails());
+
+    assertEquals(
+        ImmutableList.of(populateExpected(update).getSummary()),
+        getSummaries(new JobUpdateQuery().setKey(UPDATE1.newBuilder())));
+
+    // If the lock has been released for this job, we can start another update.
+    saveUpdate(makeJobUpdate(makeKey("update2")), Optional.of("lock2"));
+  }
+
+  private static final Optional<String> NO_TOKEN = Optional.absent();
+
+  @Test
+  public void testGetLockToken() {
+    storage.write(new MutateWork.NoResult.Quiet() {
+      @Override
+      public void execute(MutableStoreProvider storeProvider) {
+        final IJobUpdate update1 = makeJobUpdate(UPDATE1);
+        final IJobUpdate update2 = makeJobUpdate(UPDATE2);
+        saveUpdate(update1, Optional.of("lock1"));
+        assertEquals(
+            Optional.of("lock1"),
+            storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
+        assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
+
+        saveUpdate(update2, Optional.of("lock2"));
+        assertEquals(
+            Optional.of("lock1"),
+            storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
+        assertEquals(
+            Optional.of("lock2"),
+            storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
+
+        storeProvider.getLockStore().removeLock(
+            makeLock(update1.getSummary().getJobKey(), "lock1").getKey());
+        assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
+        assertEquals(
+            Optional.of("lock2"),
+            storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
+
+        storeProvider.getLockStore().removeLock(
+            makeLock(update2.getSummary().getJobKey(), "lock2").getKey());
+        assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
+        assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
+      }
+    });
+  }
+
+  @Test
+  public void testGetSummaries() {
+    String role1 = "role1";
+    IJobKey job1 = JobKeys.from(role1, "env", "name1");
+    IJobKey job2 = JobKeys.from(role1, "env", "name2");
+    IJobKey job3 = JobKeys.from(role1, "env", "name3");
+    IJobKey job4 = JobKeys.from(role1, "env", "name4");
+    IJobKey job5 = JobKeys.from("role", "env", "name5");
+    IJobUpdateSummary s1 =
+        saveSummary(makeKey(job1, "u1"), 1230L, ROLLED_BACK, "user", Optional.of("lock1"));
+    IJobUpdateSummary s2 =
+        saveSummary(makeKey(job2, "u2"), 1231L, ABORTED, "user", Optional.of("lock2"));
+    IJobUpdateSummary s3 =
+        saveSummary(makeKey(job3, "u3"), 1239L, ERROR, "user2", Optional.of("lock3"));
+    IJobUpdateSummary s4 =
+        saveSummary(makeKey(job4, "u4"), 1234L, ROLL_BACK_PAUSED, "user3", Optional.of("lock4"));
+    IJobUpdateSummary s5 =
+        saveSummary(makeKey(job5, "u5"), 1235L, ROLLING_FORWARD, "user4", Optional.of("lock5"));
+
+    // Test empty query returns all.
+    assertEquals(ImmutableList.of(s3, s5, s4, s2, s1), getSummaries(new JobUpdateQuery()));
+
+    // Test query by updateId.
+    assertEquals(
+        ImmutableList.of(s1),
+        getSummaries(new JobUpdateQuery().setKey(new JobUpdateKey(job1.newBuilder(), "u1"))));
+
+    // Test query by role.
+    assertEquals(
+        ImmutableList.of(s3, s4, s2, s1),
+        getSummaries(new JobUpdateQuery().setRole(role1)));
+
+    // Test query by job key.
+    assertEquals(
+        ImmutableList.of(s5),
+        getSummaries(new JobUpdateQuery().setJobKey(job5.newBuilder())));
+
+    // Test querying by update key.
+    assertEquals(
+        ImmutableList.of(s5),
+        getSummaries(
+            new JobUpdateQuery().setKey(new JobUpdateKey(job5.newBuilder(), s5.getUpdateId()))));
+
+    // Test querying by incorrect update keys.
+    assertEquals(
+        ImmutableList.<IJobUpdateSummary>of(),
+        getSummaries(
+            new JobUpdateQuery().setKey(new JobUpdateKey(job5.newBuilder(), s4.getUpdateId()))));
+    assertEquals(
+        ImmutableList.<IJobUpdateSummary>of(),
+        getSummaries(
+            new JobUpdateQuery().setKey(new JobUpdateKey(job4.newBuilder(), s5.getUpdateId()))));
+
+    // Test query by user.
+    assertEquals(ImmutableList.of(s2, s1), getSummaries(new JobUpdateQuery().setUser("user")));
+
+    // Test query by one status.
+    assertEquals(ImmutableList.of(s3), getSummaries(new JobUpdateQuery().setUpdateStatuses(
+        ImmutableSet.of(ERROR))));
+
+    // Test query by multiple statuses.
+    assertEquals(ImmutableList.of(s3, s2, s1), getSummaries(new JobUpdateQuery().setUpdateStatuses(
+        ImmutableSet.of(ERROR, ABORTED, ROLLED_BACK))));
+
+    // Test query by empty statuses.
+    assertEquals(
+        ImmutableList.of(s3, s5, s4, s2, s1),
+        getSummaries(new JobUpdateQuery().setUpdateStatuses(ImmutableSet.<JobUpdateStatus>of())));
+
+    // Test paging.
+    assertEquals(
+        ImmutableList.of(s3, s5),
+        getSummaries(new JobUpdateQuery().setLimit(2).setOffset(0)));
+    assertEquals(
+        ImmutableList.of(s4, s2),
+        getSummaries(new JobUpdateQuery().setLimit(2).setOffset(2)));
+    assertEquals(
+        ImmutableList.of(s1),
+        getSummaries(new JobUpdateQuery().setLimit(2).setOffset(4)));
+
+    // Test no match.
+    assertEquals(
+        ImmutableList.<IJobUpdateSummary>of(),
+        getSummaries(new JobUpdateQuery().setRole("no_match")));
+  }
+
+  @Test
+  public void testQueryDetails() {
+    IJobKey jobKey1 = JobKeys.from("role1", "env", "name1");
+    IJobUpdateKey updateId1 = makeKey(jobKey1, "u1");
+    IJobKey jobKey2 = JobKeys.from("role2", "env", "name2");
+    IJobUpdateKey updateId2 = makeKey(jobKey2, "u2");
+
+    IJobUpdate update1 = makeJobUpdate(updateId1);
+    IJobUpdate update2 = makeJobUpdate(updateId2);
+
+    assertEquals(ImmutableList.<IJobInstanceUpdateEvent>of(), getInstanceEvents(updateId2, 3));
+
+    saveUpdate(update1, Optional.of("lock1"));
+    saveUpdate(update2, Optional.of("lock2"));
+
+    updateJobDetails(populateExpected(update1), FIRST_EVENT);
+    updateJobDetails(populateExpected(update2), FIRST_EVENT);
+
+    IJobUpdateEvent jEvent11 = makeJobUpdateEvent(ROLLING_BACK, 450L);
+    IJobUpdateEvent jEvent12 = makeJobUpdateEvent(ROLLED_BACK, 500L);
+    IJobInstanceUpdateEvent iEvent11 = makeJobInstanceEvent(1, 451L, INSTANCE_ROLLING_BACK);
+    IJobInstanceUpdateEvent iEvent12 = makeJobInstanceEvent(2, 458L, INSTANCE_ROLLED_BACK);
+
+    IJobUpdateEvent jEvent21 = makeJobUpdateEvent(ROLL_FORWARD_PAUSED, 550L);
+    IJobUpdateEvent jEvent22 = makeJobUpdateEvent(ABORTED, 600L);
+    IJobInstanceUpdateEvent iEvent21 = makeJobInstanceEvent(3, 561L, INSTANCE_UPDATING);
+    IJobInstanceUpdateEvent iEvent22 = makeJobInstanceEvent(3, 570L, INSTANCE_UPDATED);
+
+    saveJobEvent(jEvent11, updateId1);
+    saveJobEvent(jEvent12, updateId1);
+    saveJobInstanceEvent(iEvent11, updateId1);
+    saveJobInstanceEvent(iEvent12, updateId1);
+
+    saveJobEvent(jEvent21, updateId2);
+    saveJobEvent(jEvent22, updateId2);
+
+    saveJobInstanceEvent(iEvent21, updateId2);
+    saveJobInstanceEvent(iEvent22, updateId2);
+
+    IJobUpdateDetails details1 = getUpdateDetails(updateId1).get();
+    IJobUpdateDetails details2 = getUpdateDetails(updateId2).get();
+
+    // Test empty query returns all.
+    assertEquals(ImmutableList.of(details2, details1), queryDetails(new JobUpdateQuery()));
+
+    // Test query by update ID.
+    assertEquals(
+        ImmutableList.of(details1),
+        queryDetails(new JobUpdateQuery().setKey(updateId1.newBuilder())));
+
+    // Test query by role.
+    assertEquals(
+        ImmutableList.of(details2),
+        queryDetails(new JobUpdateQuery().setRole(jobKey2.getRole())));
+
+    // Test query by job key.
+    assertEquals(
+        ImmutableList.of(details2),
+        queryDetails(new JobUpdateQuery().setJobKey(jobKey2.newBuilder())));
+
+    // Test query by status.
+    assertEquals(
+        ImmutableList.of(details2),
+        queryDetails(new JobUpdateQuery().setUpdateStatuses(ImmutableSet.of(ABORTED))));
+
+    // Test no match.
+    assertEquals(
+        ImmutableList.<IJobUpdateDetails>of(),
+        queryDetails(new JobUpdateQuery().setRole("no match")));
+  }
+
+  private static IJobUpdateKey makeKey(String id) {
+    return makeKey(JOB, id);
+  }
+
+  private static IJobUpdateKey makeKey(IJobKey job, String id) {
+    return IJobUpdateKey.build(new JobUpdateKey(job.newBuilder(), id));
+  }
+
+  private void assertUpdate(IJobUpdate expected) {
+    IJobUpdateKey key = expected.getSummary().getKey();
+    assertEquals(populateExpected(expected), getUpdate(key).get());
+    assertEquals(getUpdate(key).get(), getUpdateDetails(key).get().getUpdate());
+    assertEquals(getUpdateInstructions(key).get(), expected.getInstructions());
+  }
+
+  private Optional<IJobUpdate> getUpdate(final IJobUpdateKey key) {
+    return storage.read(new Quiet<Optional<IJobUpdate>>() {
+      @Override
+      public Optional<IJobUpdate> apply(Storage.StoreProvider storeProvider) {
+        return storeProvider.getJobUpdateStore().fetchJobUpdate(key);
+      }
+    });
+  }
+
+  private List<IJobInstanceUpdateEvent> getInstanceEvents(final IJobUpdateKey key, final int id) {
+    return storage.read(new Quiet<List<IJobInstanceUpdateEvent>>() {
+      @Override
+      public List<IJobInstanceUpdateEvent> apply(Storage.StoreProvider storeProvider) {
+        return storeProvider.getJobUpdateStore().fetchInstanceEvents(key, id);
+      }
+    });
+  }
+
+  private Optional<IJobUpdateInstructions> getUpdateInstructions(final IJobUpdateKey key) {
+    return storage.read(new Quiet<Optional<IJobUpdateInstructions>>() {
+      @Override
+      public Optional<IJobUpdateInstructions> apply(Storage.StoreProvider storeProvider) {
+        return storeProvider.getJobUpdateStore().fetchJobUpdateInstructions(key);
+      }
+    });
+  }
+
+  private Optional<IJobUpdateDetails> getUpdateDetails(final IJobUpdateKey key) {
+    return storage.read(new Quiet<Optional<IJobUpdateDetails>>() {
+      @Override
+      public Optional<IJobUpdateDetails> apply(Storage.StoreProvider storeProvider) {
+        return storeProvider.getJobUpdateStore().fetchJobUpdateDetails(key);
+      }
+    });
+  }
+
+  private Set<StoredJobUpdateDetails> getAllUpdateDetails() {
+    return storage.read(new Quiet<Set<StoredJobUpdateDetails>>() {
+      @Override
+      public Set<StoredJobUpdateDetails> apply(Storage.StoreProvider storeProvider) {
+        return storeProvider.getJobUpdateStore().fetchAllJobUpdateDetails();
+      }
+    });
+  }
+
+  private List<IJobUpdateDetails> queryDetails(final JobUpdateQuery query) {
+    return storage.read(new Quiet<List<IJobUpdateDetails>>() {
+      @Override
+      public List<IJobUpdateDetails> apply(Storage.StoreProvider storeProvider) {
+        return storeProvider.getJobUpdateStore().fetchJobUpdateDetails(
+            IJobUpdateQuery.build(query));
+      }
+    });
+  }
+
+  private List<IJobUpdateSummary> getSummaries(final JobUpdateQuery query) {
+    return storage.read(new Quiet<List<IJobUpdateSummary>>() {
+      @Override
+      public List<IJobUpdateSummary> apply(Storage.StoreProvider storeProvider) {
+        return storeProvider.getJobUpdateStore().fetchJobUpdateSummaries(
+            IJobUpdateQuery.build(query));
+      }
+    });
+  }
+
+  private static ILock makeLock(IJobKey jobKey, String lockToken) {
+    return ILock.build(new Lock()
+        .setKey(LockKey.job(jobKey.newBuilder()))
+        .setToken(lockToken)
+        .setTimestampMs(100)
+        .setUser("fake user"));
+  }
+
+  private IJobUpdate saveUpdate(final IJobUpdate update, final Optional<String> lockToken) {
+    storage.write(new MutateWork.NoResult.Quiet() {
+      @Override
+      public void execute(MutableStoreProvider storeProvider) {
+        if (lockToken.isPresent()) {
+          storeProvider.getLockStore().saveLock(
+              makeLock(update.getSummary().getJobKey(), lockToken.get()));
+        }
+        storeProvider.getJobUpdateStore().saveJobUpdate(update, lockToken);
+        storeProvider.getJobUpdateStore().saveJobUpdateEvent(
+            update.getSummary().getKey(),
+            FIRST_EVENT);
+      }
+    });
+
+    return update;
+  }
+
+  private IJobUpdate saveUpdateNoEvent(final IJobUpdate update, final Optional<String> lockToken) {
+    storage.write(new MutateWork.NoResult.Quiet() {
+      @Override
+      public void execute(MutableStoreProvider storeProvider) {
+        if (lockToken.isPresent()) {
+          storeProvider.getLockStore().saveLock(
+              makeLock(update.getSummary().getJobKey(), lockToken.get()));
+        }
+        storeProvider.getJobUpdateStore().saveJobUpdate(update, lockToken);
+      }
+    });
+
+    return update;
+  }
+
+  private void saveJobEvent(final IJobUpdateEvent event, final IJobUpdateKey key) {
+    storage.write(new MutateWork.NoResult.Quiet() {
+      @Override
+      public void execute(MutableStoreProvider storeProvider) {
+        storeProvider.getJobUpdateStore().saveJobUpdateEvent(key, event);
+      }
+    });
+  }
+
+  private void saveJobInstanceEvent(final IJobInstanceUpdateEvent event, final IJobUpdateKey key) {
+    storage.write(new MutateWork.NoResult.Quiet() {
+      @Override
+      public void execute(MutableStoreProvider storeProvider) {
+        storeProvider.getJobUpdateStore().saveJobInstanceUpdateEvent(key, event);
+      }
+    });
+  }
+
+  private void truncateUpdates() {
+    storage.write(new MutateWork.NoResult.Quiet() {
+      @Override
+      public void execute(MutableStoreProvider storeProvider) {
+        storeProvider.getJobUpdateStore().deleteAllUpdatesAndEvents();
+      }
+    });
+  }
+
+  private Set<IJobUpdateKey> pruneHistory(final int retainCount, final long pruningThresholdMs) {
+    return storage.write(new MutateWork.Quiet<Set<IJobUpdateKey>>() {
+      @Override
+      public Set<IJobUpdateKey> apply(MutableStoreProvider storeProvider) {
+        return storeProvider.getJobUpdateStore().pruneHistory(retainCount, pruningThresholdMs);
+      }
+    });
+  }
+
+  private void removeLock(final IJobUpdate update, final String lockToken) {
+    storage.write(new MutateWork.NoResult.Quiet() {
+      @Override
+      public void execute(MutableStoreProvider storeProvider) {
+        storeProvider.getLockStore().removeLock(
+            makeLock(update.getSummary().getJobKey(), lockToken).getKey());
+      }
+    });
+  }
+
+  private IJobUpdate populateExpected(IJobUpdate update) {
+    return populateExpected(update, ROLLING_FORWARD, CREATED_MS, CREATED_MS);
+  }
+
+  private IJobUpdate populateExpected(
+      IJobUpdate update,
+      JobUpdateStatus status,
+      long createdMs,
+      long lastMs) {
+
+    JobUpdateState state = new JobUpdateState()
+        .setCreatedTimestampMs(createdMs)
+        .setLastModifiedTimestampMs(lastMs)
+        .setStatus(status);
+    JobUpdate builder = update.newBuilder();
+    builder.getSummary().setState(state);
+    return IJobUpdate.build(builder);
+  }
+
+  private static IJobUpdateEvent makeJobUpdateEvent(JobUpdateStatus status, long timestampMs) {
+    return IJobUpdateEvent.build(
+        new JobUpdateEvent(status, timestampMs)
+            .setUser("user")
+            .setMessage("message"));
+  }
+
+  private IJobInstanceUpdateEvent makeJobInstanceEvent(
+      int instanceId,
+      long timestampMs,
+      JobUpdateAction action) {
+
+    return IJobInstanceUpdateEvent.build(
+        new JobInstanceUpdateEvent(instanceId, timestampMs, action));
+  }
+
+  private IJobUpdateDetails makeJobDetails(IJobUpdate update) {
+    return updateJobDetails(
+        update,
+        ImmutableList.of(FIRST_EVENT),
+        ImmutableList.<IJobInstanceUpdateEvent>of());
+  }
+
+  private IJobUpdateDetails updateJobDetails(IJobUpdate update, IJobUpdateEvent event) {
+    return updateJobDetails(
+        update,
+        ImmutableList.of(event),
+        ImmutableList.<IJobInstanceUpdateEvent>of());
+  }
+
+  private IJobUpdateDetails updateJobDetails(
+      IJobUpdate update,
+      List<IJobUpdateEvent> jobEvents,
+      List<IJobInstanceUpdateEvent> instanceEvents) {
+
+    return IJobUpdateDetails.build(new JobUpdateDetails()
+        .setUpdate(update.newBuilder())
+        .setUpdateEvents(IJobUpdateEvent.toBuildersList(jobEvents))
+        .setInstanceEvents(IJobInstanceUpdateEvent.toBuildersList(instanceEvents)));
+  }
+
+  private IJobUpdateSummary makeSummary(IJobUpdateKey key, String user) {
+    return IJobUpdateSummary.build(new JobUpdateSummary()
+        .setKey(key.newBuilder())
+        .setUpdateId(key.getId())
+        .setJobKey(key.getJob().newBuilder())
+        .setUser(user));
+  }
+
+  private IJobUpdateSummary saveSummary(
+      IJobUpdateKey key,
+      Long modifiedTimestampMs,
+      JobUpdateStatus status,
+      String user,
+      Optional<String> lockToken) {
+
+    IJobUpdateSummary summary = IJobUpdateSummary.build(new JobUpdateSummary()
+        .setKey(key.newBuilder())
+        .setUpdateId(key.getId())
+        .setJobKey(key.getJob().newBuilder())
+        .setUser(user));
+
+    IJobUpdate update = makeJobUpdate(summary);
+    saveUpdate(update, lockToken);
+    saveJobEvent(makeJobUpdateEvent(status, modifiedTimestampMs), key);
+    return populateExpected(update, status, CREATED_MS, modifiedTimestampMs).getSummary();
+  }
+
+  private IJobUpdate makeJobUpdate(IJobUpdateSummary summary) {
+    return IJobUpdate.build(makeJobUpdate().newBuilder().setSummary(summary.newBuilder()));
+  }
+
+  private IJobUpdate makeJobUpdate(IJobUpdateKey key) {
+    return IJobUpdate.build(makeJobUpdate().newBuilder()
+        .setSummary(makeSummary(key, "user").newBuilder()));
+  }
+
+  private IJobUpdate makeJobUpdate() {
+    return IJobUpdate.build(new JobUpdate()
+        .setInstructions(makeJobUpdateInstructions().newBuilder()));
+  }
+
+  private IJobUpdateInstructions makeJobUpdateInstructions() {
+    TaskConfig config = TaskTestUtil.makeConfig(JOB).newBuilder();
+    return IJobUpdateInstructions.build(new JobUpdateInstructions()
+        .setDesiredState(new InstanceTaskConfig()
+            .setTask(config)
+            .setInstances(ImmutableSet.of(new Range(0, 7), new Range(8, 9))))
+        .setInitialState(ImmutableSet.of(
+            new InstanceTaskConfig()
+                .setInstances(ImmutableSet.of(new Range(0, 1), new Range(2, 3)))
+                .setTask(config),
+            new InstanceTaskConfig()
+                .setInstances(ImmutableSet.of(new Range(4, 5), new Range(6, 7)))
+                .setTask(config)))
+        .setSettings(new JobUpdateSettings()
+            .setBlockIfNoPulsesAfterMs(500)
+            .setUpdateGroupSize(1)
+            .setMaxPerInstanceFailures(1)
+            .setMaxFailedInstances(1)
+            .setMaxWaitToInstanceRunningMs(100)
+            .setMinWaitInInstanceRunningMs(200)
+            .setRollbackOnFailure(true)
+            .setWaitForBatchCompletion(true)
+            .setUpdateOnlyTheseInstances(ImmutableSet.of(new Range(0, 0), new Range(3, 5)))));
+  }
+}