diff --git a/platform/persistence/queue/test/PersistenceQueueSpec.js b/platform/persistence/queue/test/PersistenceQueueSpec.js
index 315e0fd1aa..8f05b36a06 100644
--- a/platform/persistence/queue/test/PersistenceQueueSpec.js
+++ b/platform/persistence/queue/test/PersistenceQueueSpec.js
@@ -7,6 +7,28 @@ define(
         "use strict";
 
         describe("The persistence queue", function () {
+            var mockQ,
+                mockTimeout,
+                mockDialogService,
+                queue;
+
+            beforeEach(function () {
+                mockQ = jasmine.createSpyObj("$q", ['defer']);
+                mockTimeout = jasmine.createSpy("$timeout");
+                mockDialogService = jasmine.createSpyObj(
+                    'dialogService',
+                    ['getUserChoice']
+                );
+                queue = new PersistenceQueue(mockQ, mockTimeout, mockDialogService);
+            });
+
+            // PersistenceQueue is just responsible for handling injected
+            // dependencies and wiring the PersistenceQueueImpl and its
+            // handlers. Functionality is tested there, so our test here is
+            // minimal (get back expected interface, no exceptions)
+            it("provides a queue with a put method", function () {
+                expect(queue.put).toEqual(jasmine.any(Function));
+            });
 
         });
     }
diff --git a/platform/persistence/queue/test/QueuingPersistenceCapabilityDecoratorSpec.js b/platform/persistence/queue/test/QueuingPersistenceCapabilityDecoratorSpec.js
index 2543e2818d..cd1ef01f5f 100644
--- a/platform/persistence/queue/test/QueuingPersistenceCapabilityDecoratorSpec.js
+++ b/platform/persistence/queue/test/QueuingPersistenceCapabilityDecoratorSpec.js
@@ -7,6 +7,56 @@ define(
         "use strict";
 
         describe("A queuing persistence capability decorator", function () {
+            var mockQueue,
+                mockCapabilityService,
+                mockPersistenceConstructor,
+                mockPersistence,
+                mockDomainObject,
+                testModel,
+                decorator;
+
+            beforeEach(function () {
+                mockQueue = jasmine.createSpyObj('queue', ['put']);
+                mockCapabilityService = jasmine.createSpyObj(
+                    'capabilityService',
+                    ['getCapabilities']
+                );
+                testModel = { someKey: "some value" };
+                mockPersistence = jasmine.createSpyObj(
+                    'persistence',
+                    ['persist', 'refresh']
+                );
+                mockPersistenceConstructor = jasmine.createSpy();
+                mockDomainObject = jasmine.createSpyObj(
+                    'domainObject',
+                    ['getId']
+                );
+
+                mockCapabilityService.getCapabilities.andReturn({
+                    persistence: mockPersistenceConstructor
+                });
+                mockPersistenceConstructor.andReturn(mockPersistence);
+
+                decorator = new QueuingPersistenceCapabilityDecorator(
+                    mockQueue,
+                    mockCapabilityService
+                );
+            });
+
+            // Here, we verify that the decorator wraps the calls it is expected
+            // to wrap; remaining responsibility belongs to
+            // QueuingPersistenceCapability itself, which has its own tests.
+
+            it("delegates to its wrapped service", function () {
+                decorator.getCapabilities(testModel);
+                expect(mockCapabilityService.getCapabilities)
+                    .toHaveBeenCalledWith(testModel);
+            });
+
+            it("wraps its persistence capability's constructor", function () {
+                decorator.getCapabilities(testModel).persistence(mockDomainObject);
+                expect(mockPersistenceConstructor).toHaveBeenCalledWith(mockDomainObject);
+            });
 
         });
     }