diff --git a/build.gradle b/build.gradle
index f5fc81f..dd6fae5 100644
--- a/build.gradle
+++ b/build.gradle
@@ -53,7 +53,7 @@ def daggerVersion = '2.0.1'
 ext.libraries = [
         // Core libraries
         supportAnnotations             : 'com.android.support:support-annotations:' + supportLibsVersion,
-        rxJava                         : 'io.reactivex:rxjava:1.1.0',
+        rxJava                         : 'io.reactivex:rxjava:1.1.1',
 
         // Parts of StorIO
         storIOCommon                              : project(':storio-common'),
diff --git a/storio-common/src/main/java/com/pushtorefresh/storio/operations/PreparedWriteOperation.java b/storio-common/src/main/java/com/pushtorefresh/storio/operations/PreparedWriteOperation.java
new file mode 100644
index 0000000..2b9bc00
--- /dev/null
+++ b/storio-common/src/main/java/com/pushtorefresh/storio/operations/PreparedWriteOperation.java
@@ -0,0 +1,18 @@
+package com.pushtorefresh.storio.operations;
+
+import android.support.annotation.CheckResult;
+import android.support.annotation.NonNull;
+
+import rx.Completable;
+
+/**
+ * Common API of prepared write operations
+ *
+ * @param <Result> type of result
+ */
+public interface PreparedWriteOperation<Result> extends PreparedOperation<Result> {
+
+    @NonNull
+    @CheckResult
+    Completable asRxComletable();
+}
diff --git a/storio-common/src/main/java/com/pushtorefresh/storio/operations/internal/OnSubscribeExecuteAsBlockingCompletable.java b/storio-common/src/main/java/com/pushtorefresh/storio/operations/internal/OnSubscribeExecuteAsBlockingCompletable.java
new file mode 100644
index 0000000..cd5bc27
--- /dev/null
+++ b/storio-common/src/main/java/com/pushtorefresh/storio/operations/internal/OnSubscribeExecuteAsBlockingCompletable.java
@@ -0,0 +1,46 @@
+package com.pushtorefresh.storio.operations.internal;
+
+import android.support.annotation.NonNull;
+
+import com.pushtorefresh.storio.StorIOException;
+import com.pushtorefresh.storio.operations.PreparedOperation;
+
+import rx.Completable;
+
+/**
+ * Required to avoid problems with ClassLoader when RxJava is not in ClassPath
+ * We can not use anonymous classes from RxJava directly in StorIO, ClassLoader won't be happy :(
+ * <p>
+ * For internal usage only!
+ */
+public final class OnSubscribeExecuteAsBlockingCompletable implements Completable.CompletableOnSubscribe {
+
+    @NonNull
+    private final PreparedOperation preparedOperation;
+
+    private OnSubscribeExecuteAsBlockingCompletable(@NonNull PreparedOperation preparedOperation) {
+        this.preparedOperation = preparedOperation;
+    }
+
+    /**
+     * Creates new instance of {@link OnSubscribeExecuteAsBlockingCompletable}
+     *
+     * @param preparedOperation non-null instance of {@link PreparedOperation} which will be used to provide result to subscribers
+     * @return new instance of {@link OnSubscribeExecuteAsBlockingCompletable}
+     */
+    @NonNull
+    public static Completable.CompletableOnSubscribe newInstance(@NonNull PreparedOperation preparedOperation) {
+        return new OnSubscribeExecuteAsBlockingCompletable(preparedOperation);
+    }
+
+    @Override
+    public void call(@NonNull Completable.CompletableSubscriber subscriber) {
+        try {
+            preparedOperation.executeAsBlocking();
+
+            subscriber.onCompleted();
+        } catch (StorIOException e) {
+            subscriber.onError(e);
+        }
+    }
+}
diff --git a/storio-common/src/test/java/com/pushtorefresh/storio/operations/internal/OnSubscribeExecuteAsBlockingCompletableTest.java b/storio-common/src/test/java/com/pushtorefresh/storio/operations/internal/OnSubscribeExecuteAsBlockingCompletableTest.java
new file mode 100644
index 0000000..e749e81
--- /dev/null
+++ b/storio-common/src/test/java/com/pushtorefresh/storio/operations/internal/OnSubscribeExecuteAsBlockingCompletableTest.java
@@ -0,0 +1,68 @@
+package com.pushtorefresh.storio.operations.internal;
+
+import com.pushtorefresh.storio.StorIOException;
+import com.pushtorefresh.storio.operations.PreparedWriteOperation;
+
+import org.junit.Test;
+
+import rx.Completable;
+import rx.observers.TestSubscriber;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+public class OnSubscribeExecuteAsBlockingCompletableTest {
+
+    @SuppressWarnings("ResourceType")
+    @Test
+    public void shouldExecuteAsBlockingAfterSubscription() {
+        final PreparedWriteOperation preparedOperation = mock(PreparedWriteOperation.class);
+
+        TestSubscriber testSubscriber = new TestSubscriber();
+
+        verifyZeroInteractions(preparedOperation);
+
+        Completable completable = Completable.create(OnSubscribeExecuteAsBlockingCompletable.newInstance(preparedOperation));
+
+        verifyZeroInteractions(preparedOperation);
+
+        completable.subscribe(testSubscriber);
+
+        testSubscriber.assertNoErrors();
+        testSubscriber.assertCompleted();
+
+        verify(preparedOperation).executeAsBlocking();
+        verify(preparedOperation, times(0)).asRxObservable();
+        verify(preparedOperation, times(0)).asRxSingle();
+        verify(preparedOperation, times(0)).asRxComletable();
+    }
+
+    @SuppressWarnings({"ThrowableInstanceNeverThrown", "ResourceType"})
+    @Test
+    public void shouldCallOnErrorIfExceptionOccured() {
+        final PreparedWriteOperation preparedOperation = mock(PreparedWriteOperation.class);
+
+        StorIOException expectedException = new StorIOException("test exception");
+
+        when(preparedOperation.executeAsBlocking()).thenThrow(expectedException);
+
+        TestSubscriber testSubscriber = new TestSubscriber();
+
+        Completable completable = Completable.create(OnSubscribeExecuteAsBlockingCompletable.newInstance(preparedOperation));
+
+        verifyZeroInteractions(preparedOperation);
+
+        completable.subscribe(testSubscriber);
+
+        testSubscriber.assertError(expectedException);
+        testSubscriber.assertTerminalEvent();
+
+        verify(preparedOperation).executeAsBlocking();
+        verify(preparedOperation, times(0)).asRxObservable();
+        verify(preparedOperation, times(0)).asRxSingle();
+        verify(preparedOperation, times(0)).asRxComletable();
+    }
+}
diff --git a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDelete.java b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDelete.java
index 4eb1de9..10cb40c 100644
--- a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDelete.java
+++ b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDelete.java
@@ -2,7 +2,7 @@
 
 import android.support.annotation.NonNull;
 
-import com.pushtorefresh.storio.operations.PreparedOperation;
+import com.pushtorefresh.storio.operations.PreparedWriteOperation;
 import com.pushtorefresh.storio.sqlite.StorIOSQLite;
 import com.pushtorefresh.storio.sqlite.queries.DeleteQuery;
 
@@ -13,7 +13,7 @@
  *
  * @param <T> type of object to delete.
  */
-public abstract class PreparedDelete<T> implements PreparedOperation<T> {
+public abstract class PreparedDelete<T> implements PreparedWriteOperation<T> {
 
     @NonNull
     protected final StorIOSQLite storIOSQLite;
diff --git a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteByQuery.java b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteByQuery.java
index 3d97aa6..a3b37da 100644
--- a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteByQuery.java
+++ b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteByQuery.java
@@ -7,11 +7,13 @@
 
 import com.pushtorefresh.storio.StorIOException;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlocking;
+import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingCompletable;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingSingle;
 import com.pushtorefresh.storio.sqlite.Changes;
 import com.pushtorefresh.storio.sqlite.StorIOSQLite;
 import com.pushtorefresh.storio.sqlite.queries.DeleteQuery;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.schedulers.Schedulers;
@@ -126,6 +128,25 @@ public DeleteResult executeAsBlocking() {
     }
 
     /**
+     * Creates {@link Completable} which will perform Delete Operation lazily when somebody subscribes to it.
+     * <dl>
+     * <dt><b>Scheduler:</b></dt>
+     * <dd>Operates on {@link Schedulers#io()}.</dd>
+     * </dl>
+     *
+     * @return non-null {@link Completable} which will perform Delete Operation.
+     */
+    @NonNull
+    @CheckResult
+    @Override
+    public Completable asRxComletable() {
+        throwExceptionIfRxJavaIsNotAvailable("asRxCompetable()");
+        return Completable
+                .create(OnSubscribeExecuteAsBlockingCompletable.newInstance(this))
+                .subscribeOn(Schedulers.io());
+    }
+
+    /**
      * Builder for {@link PreparedDeleteByQuery}.
      */
     public static class Builder {
diff --git a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteCollectionOfObjects.java b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteCollectionOfObjects.java
index 1ecf1b1..a3782da 100644
--- a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteCollectionOfObjects.java
+++ b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteCollectionOfObjects.java
@@ -7,6 +7,7 @@
 
 import com.pushtorefresh.storio.StorIOException;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlocking;
+import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingCompletable;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingSingle;
 import com.pushtorefresh.storio.sqlite.Changes;
 import com.pushtorefresh.storio.sqlite.SQLiteTypeMapping;
@@ -21,6 +22,7 @@
 import java.util.Map;
 import java.util.Set;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.schedulers.Schedulers;
@@ -231,6 +233,25 @@
     }
 
     /**
+     * Creates {@link Completable} which will perform Delete Operation lazily when somebody subscribes to it.
+     * <dl>
+     * <dt><b>Scheduler:</b></dt>
+     * <dd>Operates on {@link Schedulers#io()}.</dd>
+     * </dl>
+     *
+     * @return non-null {@link Completable} which will perform Delete Operation.
+     */
+    @NonNull
+    @CheckResult
+    @Override
+    public Completable asRxComletable() {
+        throwExceptionIfRxJavaIsNotAvailable("asRxCompetable()");
+        return Completable
+                .create(OnSubscribeExecuteAsBlockingCompletable.newInstance(this))
+                .subscribeOn(Schedulers.io());
+    }
+
+    /**
      * Builder for {@link PreparedDeleteCollectionOfObjects}.
      *
      * @param <T> type of objects to delete.
diff --git a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteObject.java b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteObject.java
index 46eabc3..af3b335 100644
--- a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteObject.java
+++ b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteObject.java
@@ -7,11 +7,13 @@
 
 import com.pushtorefresh.storio.StorIOException;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlocking;
+import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingCompletable;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingSingle;
 import com.pushtorefresh.storio.sqlite.Changes;
 import com.pushtorefresh.storio.sqlite.SQLiteTypeMapping;
 import com.pushtorefresh.storio.sqlite.StorIOSQLite;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.schedulers.Schedulers;
@@ -152,6 +154,25 @@ public DeleteResult executeAsBlocking() {
     }
 
     /**
+     * Creates {@link Completable} which will perform Delete Operation lazily when somebody subscribes to it.
+     * <dl>
+     * <dt><b>Scheduler:</b></dt>
+     * <dd>Operates on {@link Schedulers#io()}.</dd>
+     * </dl>
+     *
+     * @return non-null {@link Completable} which will perform Delete Operation.
+     */
+    @NonNull
+    @CheckResult
+    @Override
+    public Completable asRxComletable() {
+        throwExceptionIfRxJavaIsNotAvailable("asRxCompetable()");
+        return Completable
+                .create(OnSubscribeExecuteAsBlockingCompletable.newInstance(this))
+                .subscribeOn(Schedulers.io());
+    }
+
+    /**
      * Builder for {@link PreparedDeleteObject}.
      *
      * @param <T> type of object to delete.
diff --git a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPut.java b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPut.java
index 8104f68..980df28 100644
--- a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPut.java
+++ b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPut.java
@@ -3,7 +3,7 @@
 import android.content.ContentValues;
 import android.support.annotation.NonNull;
 
-import com.pushtorefresh.storio.operations.PreparedOperation;
+import com.pushtorefresh.storio.operations.PreparedWriteOperation;
 import com.pushtorefresh.storio.sqlite.StorIOSQLite;
 
 import java.util.Arrays;
@@ -13,7 +13,7 @@
  * Prepared Put Operation for {@link StorIOSQLite} which performs insert or update data
  * in {@link StorIOSQLite}.
  */
-public abstract class PreparedPut<Result> implements PreparedOperation<Result> {
+public abstract class PreparedPut<Result> implements PreparedWriteOperation<Result> {
 
     @NonNull
     protected final StorIOSQLite storIOSQLite;
diff --git a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutCollectionOfObjects.java b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutCollectionOfObjects.java
index 663b5db..00d00b9 100644
--- a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutCollectionOfObjects.java
+++ b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutCollectionOfObjects.java
@@ -7,6 +7,7 @@
 
 import com.pushtorefresh.storio.StorIOException;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlocking;
+import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingCompletable;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingSingle;
 import com.pushtorefresh.storio.sqlite.Changes;
 import com.pushtorefresh.storio.sqlite.SQLiteTypeMapping;
@@ -21,6 +22,7 @@
 import java.util.Map;
 import java.util.Set;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.schedulers.Schedulers;
@@ -223,6 +225,25 @@
     }
 
     /**
+     * Creates {@link Completable} which will perform Put Operation lazily when somebody subscribes to it.
+     * <dl>
+     * <dt><b>Scheduler:</b></dt>
+     * <dd>Operates on {@link Schedulers#io()}.</dd>
+     * </dl>
+     *
+     * @return non-null {@link Completable} which will perform Put Operation.
+     */
+    @NonNull
+    @CheckResult
+    @Override
+    public Completable asRxComletable() {
+        throwExceptionIfRxJavaIsNotAvailable("asRxCompetable()");
+        return Completable
+                .create(OnSubscribeExecuteAsBlockingCompletable.newInstance(this))
+                .subscribeOn(Schedulers.io());
+    }
+
+    /**
      * Builder for {@link PreparedPutCollectionOfObjects}
      *
      * @param <T> type of objects to put
diff --git a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValues.java b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValues.java
index c38ef38..ed02b96 100644
--- a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValues.java
+++ b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValues.java
@@ -7,10 +7,12 @@
 
 import com.pushtorefresh.storio.StorIOException;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlocking;
+import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingCompletable;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingSingle;
 import com.pushtorefresh.storio.sqlite.Changes;
 import com.pushtorefresh.storio.sqlite.StorIOSQLite;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.schedulers.Schedulers;
@@ -127,6 +129,25 @@ public PutResult executeAsBlocking() {
     }
 
     /**
+     * Creates {@link Completable} which will perform Put Operation lazily when somebody subscribes to it.
+     * <dl>
+     * <dt><b>Scheduler:</b></dt>
+     * <dd>Operates on {@link Schedulers#io()}.</dd>
+     * </dl>
+     *
+     * @return non-null {@link Completable} which will perform Put Operation.
+     */
+    @NonNull
+    @CheckResult
+    @Override
+    public Completable asRxComletable() {
+        throwExceptionIfRxJavaIsNotAvailable("asRxCompetable()");
+        return Completable
+                .create(OnSubscribeExecuteAsBlockingCompletable.newInstance(this))
+                .subscribeOn(Schedulers.io());
+    }
+
+    /**
      * Builder for {@link PreparedPutContentValues}.
      */
     public static class Builder {
diff --git a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValuesIterable.java b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValuesIterable.java
index deb215f..76a0786 100644
--- a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValuesIterable.java
+++ b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValuesIterable.java
@@ -7,6 +7,7 @@
 
 import com.pushtorefresh.storio.StorIOException;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlocking;
+import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingCompletable;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingSingle;
 import com.pushtorefresh.storio.sqlite.Changes;
 import com.pushtorefresh.storio.sqlite.StorIOSQLite;
@@ -16,6 +17,7 @@
 import java.util.Map;
 import java.util.Set;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.schedulers.Schedulers;
@@ -181,6 +183,25 @@
     }
 
     /**
+     * Creates {@link Completable} which will perform Put Operation lazily when somebody subscribes to it.
+     * <dl>
+     * <dt><b>Scheduler:</b></dt>
+     * <dd>Operates on {@link Schedulers#io()}.</dd>
+     * </dl>
+     *
+     * @return non-null {@link Completable} which will perform Put Operation.
+     */
+    @NonNull
+    @CheckResult
+    @Override
+    public Completable asRxComletable() {
+        throwExceptionIfRxJavaIsNotAvailable("asRxCompetable()");
+        return Completable
+                .create(OnSubscribeExecuteAsBlockingCompletable.newInstance(this))
+                .subscribeOn(Schedulers.io());
+    }
+
+    /**
      * Builder for {@link PreparedPutContentValuesIterable}
      */
     public static class Builder {
diff --git a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutObject.java b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutObject.java
index 7515c41..0481457 100644
--- a/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutObject.java
+++ b/storio-sqlite/src/main/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutObject.java
@@ -7,11 +7,13 @@
 
 import com.pushtorefresh.storio.StorIOException;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlocking;
+import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingCompletable;
 import com.pushtorefresh.storio.operations.internal.OnSubscribeExecuteAsBlockingSingle;
 import com.pushtorefresh.storio.sqlite.Changes;
 import com.pushtorefresh.storio.sqlite.SQLiteTypeMapping;
 import com.pushtorefresh.storio.sqlite.StorIOSQLite;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.schedulers.Schedulers;
@@ -152,6 +154,25 @@ public PutResult executeAsBlocking() {
     }
 
     /**
+     * Creates {@link Completable} which will perform Put Operation lazily when somebody subscribes to it.
+     * <dl>
+     * <dt><b>Scheduler:</b></dt>
+     * <dd>Operates on {@link Schedulers#io()}.</dd>
+     * </dl>
+     *
+     * @return non-null {@link Completable} which will perform Put Operation.
+     */
+    @NonNull
+    @CheckResult
+    @Override
+    public Completable asRxComletable() {
+        throwExceptionIfRxJavaIsNotAvailable("asRxCompetable()");
+        return Completable
+                .create(OnSubscribeExecuteAsBlockingCompletable.newInstance(this))
+                .subscribeOn(Schedulers.io());
+    }
+
+    /**
      * Builder for {@link PreparedPutObject}.
      *
      * @param <T> type of object to put.
diff --git a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/design/DeleteOperationDesignTest.java b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/design/DeleteOperationDesignTest.java
index 36f3ffb..0d217d0 100644
--- a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/design/DeleteOperationDesignTest.java
+++ b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/design/DeleteOperationDesignTest.java
@@ -9,6 +9,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 
@@ -124,4 +125,41 @@ public void deleteByQuerySingle() {
                 .prepare()
                 .asRxSingle();
     }
+
+    @Test
+    public void deleteObjectCompletable() {
+        User user = newUser();
+
+        Completable completableDelete = storIOSQLite()
+                .delete()
+                .object(user)
+                .withDeleteResolver(UserTableMeta.DELETE_RESOLVER)
+                .prepare()
+                .asRxComletable();
+    }
+
+    @Test
+    public void deleteCollectionOfObjectsCompletable() {
+        List<User> users = new ArrayList<User>();
+
+        Completable completableDelete = storIOSQLite()
+                .delete()
+                .objects(users)
+                .withDeleteResolver(UserTableMeta.DELETE_RESOLVER)
+                .prepare()
+                .asRxComletable();
+    }
+
+    @Test
+    public void deleteByQueryCompletable() {
+        Completable completableDelete = storIOSQLite()
+                .delete()
+                .byQuery(DeleteQuery.builder()
+                        .table("users")
+                        .where("email = ?")
+                        .whereArgs("artem.zinnatullin@gmail.com")
+                        .build())
+                .prepare()
+                .asRxComletable();
+    }
 }
diff --git a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/design/PutOperationDesignTest.java b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/design/PutOperationDesignTest.java
index 63c490b..a4cbcad 100644
--- a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/design/PutOperationDesignTest.java
+++ b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/design/PutOperationDesignTest.java
@@ -14,6 +14,7 @@
 
 import java.util.Arrays;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 
@@ -174,4 +175,39 @@ public void putContentValuesIterableSingle() {
                 .asRxSingle();
     }
 
+    @Test
+    public void putObjectCompletable() {
+        User user = newUser();
+
+        Completable completablePut = storIOSQLite()
+                .put()
+                .object(user)
+                .withPutResolver(UserTableMeta.PUT_RESOLVER)
+                .prepare()
+                .asRxComletable();
+    }
+
+    @Test
+    public void putContentValuesCompletable() {
+        Completable completablePut = storIOSQLite()
+                .put()
+                .contentValues(mock(ContentValues.class))
+                .withPutResolver(CONTENT_VALUES_PUT_RESOLVER)
+                .prepare()
+                .asRxComletable();
+    }
+
+    @Test
+    public void putContentValuesIterableCompletable() {
+        Iterable<ContentValues> contentValuesIterable
+                = Arrays.asList(mock(ContentValues.class));
+
+        Completable completablePut = storIOSQLite()
+                .put()
+                .contentValues(contentValuesIterable)
+                .withPutResolver(CONTENT_VALUES_PUT_RESOLVER)
+                .prepare()
+                .asRxComletable();
+    }
+
 }
diff --git a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/DeleteStub.java b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/DeleteStub.java
index c717269..3c59333 100644
--- a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/DeleteStub.java
+++ b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/DeleteStub.java
@@ -13,6 +13,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.functions.Action1;
@@ -200,6 +201,10 @@ public void call(DeleteResults<TestItem> deleteResults) {
                 .checkBehaviorOfObservable();
     }
 
+    void verifyBehaviorForMultipleObjects(@NonNull Completable completable) {
+        verifyBehaviorForMultipleObjects(completable.<DeleteResults<TestItem>>toObservable());
+    }
+
     void verifyBehaviorForOneObject(@NonNull DeleteResult deleteResult) {
         verifyBehaviorForMultipleObjects(DeleteResults.newInstance(singletonMap(itemsRequestedForDelete.get(0), deleteResult)));
     }
@@ -217,6 +222,10 @@ public void call(DeleteResult deleteResult) {
                 .checkBehaviorOfObservable();
     }
 
+    void verifyBehaviorForOneObject(@NonNull Completable completable) {
+        verifyBehaviorForOneObject(completable.<DeleteResult>toObservable());
+    }
+
     void verifyBehaviorForOneObject(@NonNull Single<DeleteResult> single) {
         new ObservableBehaviorChecker<DeleteResult>()
                 .observable(single.toObservable())
diff --git a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteByQueryTest.java b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteByQueryTest.java
index 384a2f6..a8af1de 100644
--- a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteByQueryTest.java
+++ b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteByQueryTest.java
@@ -135,6 +135,45 @@ public void shouldPerformDeletionByQuerySingle() {
     }
 
     @Test
+    public void shouldPerformDeletionByQueryCompletable() {
+        final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
+        final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
+
+        when(storIOSQLite.lowLevel()).thenReturn(internal);
+
+        final DeleteQuery deleteQuery = DeleteQuery.builder()
+                .table("test_table")
+                .where("column1 = ?")
+                .whereArgs(1)
+                .build();
+
+        //noinspection unchecked
+        final DeleteResolver<DeleteQuery> deleteResolver = mock(DeleteResolver.class);
+
+        final DeleteResult expectedDeleteResult = DeleteResult.newInstance(1, deleteQuery.table());
+
+        when(deleteResolver.performDelete(same(storIOSQLite), same(deleteQuery)))
+                .thenReturn(expectedDeleteResult);
+
+        final TestSubscriber<DeleteResult> testSubscriber = new TestSubscriber<DeleteResult>();
+
+        new PreparedDeleteByQuery.Builder(storIOSQLite, deleteQuery)
+                .withDeleteResolver(deleteResolver)
+                .prepare()
+                .asRxComletable()
+                .subscribe(testSubscriber);
+
+        testSubscriber.awaitTerminalEvent();
+        testSubscriber.assertNoErrors();
+        testSubscriber.assertNoValues();
+
+        verify(storIOSQLite).lowLevel();
+        verify(deleteResolver).performDelete(same(storIOSQLite), same(deleteQuery));
+        verify(internal).notifyAboutChanges(eq(Changes.newInstance(deleteQuery.table())));
+        verifyNoMoreInteractions(storIOSQLite, internal, deleteResolver);
+    }
+
+    @Test
     public void shouldWrapExceptionIntoStorIOExceptionBlocking() {
         final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
         final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
@@ -234,6 +273,41 @@ public void shouldWrapExceptionIntoStorIOExceptionSingle() {
     }
 
     @Test
+    public void shouldWrapExceptionIntoStorIOExceptionCompletable() {
+        final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
+        final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
+
+        when(storIOSQLite.lowLevel()).thenReturn(internal);
+
+        //noinspection unchecked
+        final DeleteResolver<DeleteQuery> deleteResolver = mock(DeleteResolver.class);
+
+        when(deleteResolver.performDelete(same(storIOSQLite), any(DeleteQuery.class)))
+                .thenThrow(new IllegalStateException("test exception"));
+
+        final TestSubscriber<DeleteResult> testSubscriber = new TestSubscriber<DeleteResult>();
+
+        new PreparedDeleteByQuery.Builder(storIOSQLite, DeleteQuery.builder().table("test_table").build())
+                .withDeleteResolver(deleteResolver)
+                .prepare()
+                .asRxComletable()
+                .subscribe(testSubscriber);
+
+        testSubscriber.awaitTerminalEvent();
+        testSubscriber.assertNoValues();
+        testSubscriber.assertError(StorIOException.class);
+
+        //noinspection ThrowableResultOfMethodCallIgnored
+        StorIOException expected = (StorIOException) testSubscriber.getOnErrorEvents().get(0);
+
+        IllegalStateException cause = (IllegalStateException) expected.getCause();
+        assertThat(cause).hasMessage("test exception");
+
+        verify(deleteResolver).performDelete(same(storIOSQLite), any(DeleteQuery.class));
+        verifyNoMoreInteractions(storIOSQLite, internal, deleteResolver);
+    }
+
+    @Test
     public void shouldNotNotifyIfWasNotDeleted() {
         final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
         final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
diff --git a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteCollectionOfObjectsTest.java b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteCollectionOfObjectsTest.java
index 51efde0..ee277c6 100644
--- a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteCollectionOfObjectsTest.java
+++ b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteCollectionOfObjectsTest.java
@@ -10,6 +10,7 @@
 
 import java.util.List;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.observers.TestSubscriber;
@@ -159,6 +160,38 @@ public void shouldDeleteObjectsWithoutTypeMappingWithTransactionAsSingle() {
 
             deleteStub.verifyBehaviorForMultipleObjects(single);
         }
+
+        @Test
+        public void shouldDeleteObjectsWithoutTypeMappingWithoutTransactionAsCompletable() {
+            final DeleteStub deleteStub
+                    = DeleteStub.newStubForMultipleObjectsWithoutTypeMappingWithoutTransaction();
+
+            final Completable completable = deleteStub.storIOSQLite
+                    .delete()
+                    .objects(deleteStub.itemsRequestedForDelete)
+                    .useTransaction(false)
+                    .withDeleteResolver(deleteStub.deleteResolver)
+                    .prepare()
+                    .asRxComletable();
+
+            deleteStub.verifyBehaviorForMultipleObjects(completable);
+        }
+
+        @Test
+        public void shouldDeleteObjectsWithoutTypeMappingWithTransactionAsCompletable() {
+            final DeleteStub deleteStub
+                    = DeleteStub.newStubForMultipleObjectsWithoutTypeMappingWithTransaction();
+
+            final Completable completable = deleteStub.storIOSQLite
+                    .delete()
+                    .objects(deleteStub.itemsRequestedForDelete)
+                    .useTransaction(true)
+                    .withDeleteResolver(deleteStub.deleteResolver)
+                    .prepare()
+                    .asRxComletable();
+
+            deleteStub.verifyBehaviorForMultipleObjects(completable);
+        }
     }
 
     public static class WithTypeMapping {
@@ -282,6 +315,36 @@ public void shouldDeleteObjectsWithTypeMappingWithTransactionSingle() {
 
             deleteStub.verifyBehaviorForMultipleObjects(single);
         }
+
+        @Test
+        public void shouldDeleteObjectsWithTypeMappingWithoutTransactionCompletable() {
+            final DeleteStub deleteStub
+                    = DeleteStub.newStubForMultipleObjectsWithTypeMappingWithoutTransaction();
+
+            final Completable completable = deleteStub.storIOSQLite
+                    .delete()
+                    .objects(deleteStub.itemsRequestedForDelete)
+                    .useTransaction(false)
+                    .prepare()
+                    .asRxComletable();
+
+            deleteStub.verifyBehaviorForMultipleObjects(completable);
+        }
+
+        @Test
+        public void shouldDeleteObjectsWithTypeMappingWithTransactionCompletable() {
+            final DeleteStub deleteStub
+                    = DeleteStub.newStubForMultipleObjectsWithTypeMappingWithTransaction();
+
+            final Completable completable = deleteStub.storIOSQLite
+                    .delete()
+                    .objects(deleteStub.itemsRequestedForDelete)
+                    .useTransaction(true)
+                    .prepare()
+                    .asRxComletable();
+
+            deleteStub.verifyBehaviorForMultipleObjects(completable);
+        }
     }
 
     public static class NoTypeMappingError {
@@ -387,6 +450,40 @@ public void shouldThrowExceptionIfNoTypeMappingWasFoundWithoutTransactionWithout
         }
 
         @Test
+        public void shouldThrowExceptionIfNoTypeMappingWasFoundWithoutTransactionWithoutAffectingDbAsCompletable() {
+            final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
+            final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
+
+            when(storIOSQLite.lowLevel()).thenReturn(internal);
+
+            when(storIOSQLite.delete()).thenReturn(new PreparedDelete.Builder(storIOSQLite));
+
+            final List<TestItem> items = asList(TestItem.newInstance(), TestItem.newInstance());
+
+            final TestSubscriber<DeleteResults<TestItem>> testSubscriber = new TestSubscriber<DeleteResults<TestItem>>();
+
+            storIOSQLite
+                    .delete()
+                    .objects(items)
+                    .useTransaction(false)
+                    .prepare()
+                    .asRxComletable()
+                    .subscribe(testSubscriber);
+
+            testSubscriber.awaitTerminalEvent();
+            testSubscriber.assertNoValues();
+            assertThat(testSubscriber.getOnErrorEvents().get(0))
+                    .isInstanceOf(StorIOException.class)
+                    .hasCauseInstanceOf(IllegalStateException.class);
+
+            verify(storIOSQLite).delete();
+            verify(storIOSQLite).lowLevel();
+            verify(internal).typeMapping(TestItem.class);
+            verify(internal, never()).delete(any(DeleteQuery.class));
+            verifyNoMoreInteractions(storIOSQLite, internal);
+        }
+
+        @Test
         public void shouldThrowExceptionIfNoTypeMappingWasFoundWithTransactionWithoutAffectingDbBlocking() {
             final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
             final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
@@ -485,6 +582,40 @@ public void shouldThrowExceptionIfNoTypeMappingWasFoundWithTransactionWithoutAff
             verify(internal, never()).delete(any(DeleteQuery.class));
             verifyNoMoreInteractions(storIOSQLite, internal);
         }
+
+        @Test
+        public void shouldThrowExceptionIfNoTypeMappingWasFoundWithTransactionWithoutAffectingDbAsCompletable() {
+            final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
+            final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
+
+            when(storIOSQLite.lowLevel()).thenReturn(internal);
+
+            when(storIOSQLite.delete()).thenReturn(new PreparedDelete.Builder(storIOSQLite));
+
+            final List<TestItem> items = asList(TestItem.newInstance(), TestItem.newInstance());
+
+            final TestSubscriber<DeleteResults<TestItem>> testSubscriber = new TestSubscriber<DeleteResults<TestItem>>();
+
+            storIOSQLite
+                    .delete()
+                    .objects(items)
+                    .useTransaction(true)
+                    .prepare()
+                    .asRxComletable()
+                    .subscribe(testSubscriber);
+
+            testSubscriber.awaitTerminalEvent();
+            testSubscriber.assertNoValues();
+            assertThat(testSubscriber.getOnErrorEvents().get(0))
+                    .isInstanceOf(StorIOException.class)
+                    .hasCauseInstanceOf(IllegalStateException.class);
+
+            verify(storIOSQLite).delete();
+            verify(storIOSQLite).lowLevel();
+            verify(internal).typeMapping(TestItem.class);
+            verify(internal, never()).delete(any(DeleteQuery.class));
+            verifyNoMoreInteractions(storIOSQLite, internal);
+        }
     }
 
     public static class OtherTests {
@@ -605,5 +736,46 @@ public void shouldFinishTransactionIfExceptionHasOccurredSingle() {
             verify(deleteResolver).performDelete(same(storIOSQLite), anyObject());
             verifyNoMoreInteractions(storIOSQLite, internal, deleteResolver);
         }
+
+        @Test
+        public void shouldFinishTransactionIfExceptionHasOccurredCompletable() {
+            final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
+            final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
+
+            when(storIOSQLite.lowLevel()).thenReturn(internal);
+
+            //noinspection unchecked
+            final DeleteResolver<Object> deleteResolver = mock(DeleteResolver.class);
+
+            when(deleteResolver.performDelete(same(storIOSQLite), anyObject()))
+                    .thenThrow(new IllegalStateException("test exception"));
+
+            final TestSubscriber<DeleteResults<Object>> testSubscriber = new TestSubscriber<DeleteResults<Object>>();
+
+            new PreparedDeleteCollectionOfObjects.Builder<Object>(storIOSQLite, singletonList(new Object()))
+                    .useTransaction(true)
+                    .withDeleteResolver(deleteResolver)
+                    .prepare()
+                    .asRxComletable()
+                    .subscribe(testSubscriber);
+
+            testSubscriber.awaitTerminalEvent();
+            testSubscriber.assertNoValues();
+            testSubscriber.assertError(StorIOException.class);
+
+            //noinspection ThrowableResultOfMethodCallIgnored
+            StorIOException expected = (StorIOException) testSubscriber.getOnErrorEvents().get(0);
+
+            IllegalStateException cause = (IllegalStateException) expected.getCause();
+            assertThat(cause).hasMessage("test exception");
+
+            verify(internal).beginTransaction();
+            verify(internal, never()).setTransactionSuccessful();
+            verify(internal).endTransaction();
+
+            verify(storIOSQLite).lowLevel();
+            verify(deleteResolver).performDelete(same(storIOSQLite), anyObject());
+            verifyNoMoreInteractions(storIOSQLite, internal, deleteResolver);
+        }
     }
 }
diff --git a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteObjectTest.java b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteObjectTest.java
index 6fc4b3d..3567b5f 100644
--- a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteObjectTest.java
+++ b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/delete/PreparedDeleteObjectTest.java
@@ -8,6 +8,7 @@
 import org.junit.experimental.runners.Enclosed;
 import org.junit.runner.RunWith;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.observers.TestSubscriber;
@@ -69,6 +70,20 @@ public void shouldDeleteObjectWithoutTypeMappingAsSingle() {
         }
 
         @Test
+        public void shouldDeleteObjectWithoutTypeMappingAsCompletable() {
+            final DeleteStub deleteStub = DeleteStub.newStubForOneObjectWithoutTypeMapping();
+
+            final Completable completable = deleteStub.storIOSQLite
+                    .delete()
+                    .object(deleteStub.itemsRequestedForDelete.get(0))
+                    .withDeleteResolver(deleteStub.deleteResolver)
+                    .prepare()
+                    .asRxComletable();
+
+            deleteStub.verifyBehaviorForOneObject(completable);
+        }
+
+        @Test
         public void shouldNotNotifyIfWasNotDeleted() {
             final DeleteStub deleteStub = DeleteStub.newStubForOneObjectWithoutTypeMappingNothingDeleted();
 
@@ -123,6 +138,19 @@ public void shouldDeleteObjectWithTypeMappingAsSingle() {
 
             deleteStub.verifyBehaviorForOneObject(single);
         }
+
+        @Test
+        public void shouldDeleteObjectWithTypeMappingAsCompletable() {
+            final DeleteStub deleteStub = DeleteStub.newStubForOneObjectWithTypeMapping();
+
+            final Completable completable = deleteStub.storIOSQLite
+                    .delete()
+                    .object(deleteStub.itemsRequestedForDelete.get(0))
+                    .prepare()
+                    .asRxComletable();
+
+            deleteStub.verifyBehaviorForOneObject(completable);
+        }
     }
 
     public static class NoTypeMappingError {
@@ -215,5 +243,35 @@ public void shouldThrowExceptionIfNoTypeMappingWasFoundWithoutAffectingDbAsSingl
             verify(internal, never()).delete(any(DeleteQuery.class));
             verifyNoMoreInteractions(storIOSQLite, internal);
         }
+
+        @Test
+        public void shouldThrowExceptionIfNoTypeMappingWasFoundWithoutAffectingDbAsCompletable() {
+            final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
+            final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
+
+            when(storIOSQLite.lowLevel()).thenReturn(internal);
+
+            when(storIOSQLite.delete()).thenReturn(new PreparedDelete.Builder(storIOSQLite));
+
+            final TestSubscriber<DeleteResult> testSubscriber = new TestSubscriber<DeleteResult>();
+
+            storIOSQLite
+                    .delete()
+                    .object(TestItem.newInstance())
+                    .prepare()
+                    .asRxComletable()
+                    .subscribe(testSubscriber);
+
+            testSubscriber.awaitTerminalEvent();
+            testSubscriber.assertNoValues();
+            assertThat(testSubscriber.getOnErrorEvents().get(0)).
+                    hasCauseInstanceOf(IllegalStateException.class);
+
+            verify(storIOSQLite).delete();
+            verify(storIOSQLite).lowLevel();
+            verify(internal).typeMapping(TestItem.class);
+            verify(internal, never()).delete(any(DeleteQuery.class));
+            verifyNoMoreInteractions(storIOSQLite, internal);
+        }
     }
 }
diff --git a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutCollectionOfObjectsTest.java b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutCollectionOfObjectsTest.java
index 529c654..8fed576 100644
--- a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutCollectionOfObjectsTest.java
+++ b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutCollectionOfObjectsTest.java
@@ -13,6 +13,7 @@
 
 import java.util.List;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.observers.TestSubscriber;
@@ -130,6 +131,38 @@ public void shouldPutObjectsWithoutTypeMappingWithTransactionAsSingle() {
 
             putStub.verifyBehaviorForMultipleObjects(single);
         }
+
+        @Test
+        public void shouldPutObjectsWithoutTypeMappingWithoutTransactionAsCompletable() {
+            final PutObjectsStub putStub
+                    = PutObjectsStub.newPutStubForMultipleObjectsWithoutTypeMappingWithoutTransaction();
+
+            final Completable completable = putStub.storIOSQLite
+                    .put()
+                    .objects(putStub.items)
+                    .useTransaction(false)
+                    .withPutResolver(putStub.putResolver)
+                    .prepare()
+                    .asRxComletable();
+
+            putStub.verifyBehaviorForMultipleObjects(completable);
+        }
+
+        @Test
+        public void shouldPutObjectsWithoutTypeMappingWithTransactionAsCompletable() {
+            final PutObjectsStub putStub
+                    = PutObjectsStub.newPutStubForMultipleObjectsWithoutTypeMappingWithTransaction();
+
+            final Completable completable = putStub.storIOSQLite
+                    .put()
+                    .objects(putStub.items)
+                    .useTransaction(true)
+                    .withPutResolver(putStub.putResolver)
+                    .prepare()
+                    .asRxComletable();
+
+            putStub.verifyBehaviorForMultipleObjects(completable);
+        }
     }
 
     public static class WithTypeMapping {
@@ -223,6 +256,36 @@ public void shouldPutObjectsWithTypeMappingWithTransactionAsSingle() {
 
             putStub.verifyBehaviorForMultipleObjects(single);
         }
+
+        @Test
+        public void shouldPutObjectsWithTypeMappingWithoutTransactionAsCompletable() {
+            final PutObjectsStub putStub
+                    = PutObjectsStub.newPutStubForMultipleObjectsWithTypeMappingWithoutTransaction();
+
+            final Completable completable = putStub.storIOSQLite
+                    .put()
+                    .objects(putStub.items)
+                    .useTransaction(false)
+                    .prepare()
+                    .asRxComletable();
+
+            putStub.verifyBehaviorForMultipleObjects(completable);
+        }
+
+        @Test
+        public void shouldPutObjectsWithTypeMappingWithTransactionAsCompletable() {
+            final PutObjectsStub putStub
+                    = PutObjectsStub.newPutStubForMultipleObjectsWithTypeMappingWithTransaction();
+
+            final Completable completable = putStub.storIOSQLite
+                    .put()
+                    .objects(putStub.items)
+                    .useTransaction(true)
+                    .prepare()
+                    .asRxComletable();
+
+            putStub.verifyBehaviorForMultipleObjects(completable);
+        }
     }
 
     public static class NoTypeMappingError {
@@ -331,6 +394,41 @@ public void shouldThrowExceptionIfNoTypeMappingWasFoundWithoutTransactionWithout
         }
 
         @Test
+        public void shouldThrowExceptionIfNoTypeMappingWasFoundWithoutTransactionWithoutAffectingDbAsCompletable() {
+            final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
+            final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
+
+            when(storIOSQLite.lowLevel()).thenReturn(internal);
+
+            when(storIOSQLite.put()).thenReturn(new PreparedPut.Builder(storIOSQLite));
+
+            final List<TestItem> items = asList(TestItem.newInstance(), TestItem.newInstance());
+
+            final TestSubscriber<PutResults<TestItem>> testSubscriber = new TestSubscriber<PutResults<TestItem>>();
+
+            storIOSQLite
+                    .put()
+                    .objects(items)
+                    .useTransaction(false)
+                    .prepare()
+                    .asRxComletable()
+                    .subscribe(testSubscriber);
+
+            testSubscriber.awaitTerminalEvent();
+            testSubscriber.assertNoValues();
+            assertThat(testSubscriber.getOnErrorEvents().get(0))
+                    .isInstanceOf(StorIOException.class)
+                    .hasCauseInstanceOf(IllegalStateException.class);
+
+            verify(storIOSQLite).put();
+            verify(storIOSQLite).lowLevel();
+            verify(internal).typeMapping(TestItem.class);
+            verify(internal, never()).insert(any(InsertQuery.class), any(ContentValues.class));
+            verify(internal, never()).update(any(UpdateQuery.class), any(ContentValues.class));
+            verifyNoMoreInteractions(storIOSQLite, internal);
+        }
+
+        @Test
         public void shouldThrowExceptionIfNoTypeMappingWasFoundWithTransactionWithoutAffectingDbBlocking() {
             final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
             final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
@@ -432,6 +530,41 @@ public void shouldThrowExceptionIfNoTypeMappingWasFoundWithTransactionWithoutAff
             verify(internal, never()).update(any(UpdateQuery.class), any(ContentValues.class));
             verifyNoMoreInteractions(storIOSQLite, internal);
         }
+
+        @Test
+        public void shouldThrowExceptionIfNoTypeMappingWasFoundWithTransactionWithoutAffectingDbAsCompletable() {
+            final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
+            final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
+
+            when(storIOSQLite.lowLevel()).thenReturn(internal);
+
+            when(storIOSQLite.put()).thenReturn(new PreparedPut.Builder(storIOSQLite));
+
+            final List<TestItem> items = asList(TestItem.newInstance(), TestItem.newInstance());
+
+            final TestSubscriber<PutResults<TestItem>> testSubscriber = new TestSubscriber<PutResults<TestItem>>();
+
+            storIOSQLite
+                    .put()
+                    .objects(items)
+                    .useTransaction(true)
+                    .prepare()
+                    .asRxComletable()
+                    .subscribe(testSubscriber);
+
+            testSubscriber.awaitTerminalEvent();
+            testSubscriber.assertNoValues();
+            assertThat(testSubscriber.getOnErrorEvents().get(0))
+                    .isInstanceOf(StorIOException.class)
+                    .hasCauseInstanceOf(IllegalStateException.class);
+
+            verify(storIOSQLite).put();
+            verify(storIOSQLite).lowLevel();
+            verify(internal).typeMapping(TestItem.class);
+            verify(internal, never()).insert(any(InsertQuery.class), any(ContentValues.class));
+            verify(internal, never()).update(any(UpdateQuery.class), any(ContentValues.class));
+            verifyNoMoreInteractions(storIOSQLite, internal);
+        }
     }
 
     public static class OtherTests {
@@ -558,6 +691,48 @@ public void shouldFinishTransactionIfExceptionHasOccurredSingle() {
         }
 
         @Test
+        public void shouldFinishTransactionIfExceptionHasOccurredCompletable() {
+            final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
+            final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
+
+            when(storIOSQLite.lowLevel()).thenReturn(internal);
+
+            //noinspection unchecked
+            final PutResolver<Object> putResolver = mock(PutResolver.class);
+
+            when(putResolver.performPut(same(storIOSQLite), anyObject()))
+                    .thenThrow(new IllegalStateException("test exception"));
+
+            final List<Object> objects = singletonList(new Object());
+
+            final TestSubscriber<PutResults<Object>> testSubscriber = new TestSubscriber<PutResults<Object>>();
+
+            new PreparedPutCollectionOfObjects.Builder<Object>(storIOSQLite, objects)
+                    .useTransaction(true)
+                    .withPutResolver(putResolver)
+                    .prepare()
+                    .asRxComletable()
+                    .subscribe(testSubscriber);
+
+            testSubscriber.awaitTerminalEvent();
+            testSubscriber.assertNoValues();
+            testSubscriber.assertError(StorIOException.class);
+
+            //noinspection ThrowableResultOfMethodCallIgnored
+            StorIOException expected = (StorIOException) testSubscriber.getOnErrorEvents().get(0);
+            IllegalStateException cause = (IllegalStateException) expected.getCause();
+            assertThat(cause).hasMessage("test exception");
+
+            verify(internal).beginTransaction();
+            verify(internal, never()).setTransactionSuccessful();
+            verify(internal).endTransaction();
+
+            verify(storIOSQLite).lowLevel();
+            verify(putResolver).performPut(same(storIOSQLite), anyObject());
+            verifyNoMoreInteractions(storIOSQLite, internal, putResolver);
+        }
+
+        @Test
         public void verifyBehaviorInCaseOfExceptionWithoutTransactionBlocking() {
             final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
             final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
@@ -682,5 +857,49 @@ public void verifyBehaviorInCaseOfExceptionWithoutTransactionSingle() {
             verify(putResolver).performPut(same(storIOSQLite), anyObject());
             verifyNoMoreInteractions(storIOSQLite, internal, putResolver);
         }
+
+        @Test
+        public void verifyBehaviorInCaseOfExceptionWithoutTransactionCompletable() {
+            final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
+            final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
+
+            when(storIOSQLite.lowLevel()).thenReturn(internal);
+
+            //noinspection unchecked
+            final PutResolver<Object> putResolver = mock(PutResolver.class);
+
+            when(putResolver.performPut(same(storIOSQLite), anyObject()))
+                    .thenThrow(new IllegalStateException("test exception"));
+
+            final List<Object> objects = singletonList(new Object());
+
+            final TestSubscriber<PutResults<Object>> testSubscriber = new TestSubscriber<PutResults<Object>>();
+
+            new PreparedPutCollectionOfObjects.Builder<Object>(storIOSQLite, objects)
+                    .useTransaction(false)
+                    .withPutResolver(putResolver)
+                    .prepare()
+                    .asRxComletable()
+                    .subscribe(testSubscriber);
+
+            testSubscriber.awaitTerminalEvent();
+            testSubscriber.assertNoValues();
+            testSubscriber.assertError(StorIOException.class);
+
+            //noinspection ThrowableResultOfMethodCallIgnored
+            StorIOException expected = (StorIOException) testSubscriber.getOnErrorEvents().get(0);
+
+            IllegalStateException cause = (IllegalStateException) expected.getCause();
+            assertThat(cause).hasMessage("test exception");
+
+            // Main checks of this test
+            verify(internal, never()).beginTransaction();
+            verify(internal, never()).setTransactionSuccessful();
+            verify(internal, never()).endTransaction();
+
+            verify(storIOSQLite).lowLevel();
+            verify(putResolver).performPut(same(storIOSQLite), anyObject());
+            verifyNoMoreInteractions(storIOSQLite, internal, putResolver);
+        }
     }
 }
diff --git a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValuesIterableTest.java b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValuesIterableTest.java
index 4308f19..076319b 100644
--- a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValuesIterableTest.java
+++ b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValuesIterableTest.java
@@ -9,6 +9,7 @@
 
 import java.util.List;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.observers.TestSubscriber;
@@ -72,6 +73,21 @@ public void putMultipleSingleWithTransaction() {
     }
 
     @Test
+    public void putMultipleCompletableWithTransaction() {
+        final PutContentValuesStub putStub = PutContentValuesStub.newPutStubForMultipleContentValues(true);
+
+        final Completable completable = putStub.storIOSQLite
+                .put()
+                .contentValues(putStub.contentValues)
+                .withPutResolver(putStub.putResolver)
+                .useTransaction(true)
+                .prepare()
+                .asRxComletable();
+
+        putStub.verifyBehaviorForMultipleContentValues(completable);
+    }
+
+    @Test
     public void putMultipleBlockingWithoutTransaction() {
         final PutContentValuesStub putStub = PutContentValuesStub.newPutStubForMultipleContentValues(false);
 
@@ -117,6 +133,21 @@ public void putMultipleSingleWithoutTransaction() {
     }
 
     @Test
+    public void putMultipleCompletableWithoutTransaction() {
+        final PutContentValuesStub putStub = PutContentValuesStub.newPutStubForMultipleContentValues(false);
+
+        final Completable completable = putStub.storIOSQLite
+                .put()
+                .contentValues(putStub.contentValues)
+                .withPutResolver(putStub.putResolver)
+                .useTransaction(false)
+                .prepare()
+                .asRxComletable();
+
+        putStub.verifyBehaviorForMultipleContentValues(completable);
+    }
+
+    @Test
     public void shouldFinishTransactionIfExceptionHasOccurredBlocking() {
         final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
         final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
@@ -241,6 +272,49 @@ public void shouldFinishTransactionIfExceptionHasOccurredSingle() {
     }
 
     @Test
+    public void shouldFinishTransactionIfExceptionHasOccurredCompletable() {
+        final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
+        final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
+
+        when(storIOSQLite.lowLevel()).thenReturn(internal);
+
+        //noinspection unchecked
+        final PutResolver<ContentValues> putResolver = mock(PutResolver.class);
+
+        final List<ContentValues> contentValues = singletonList(mock(ContentValues.class));
+
+        when(putResolver.performPut(same(storIOSQLite), any(ContentValues.class)))
+                .thenThrow(new IllegalStateException("test exception"));
+
+        final TestSubscriber<PutResults<ContentValues>> testSubscriber = new TestSubscriber<PutResults<ContentValues>>();
+
+        new PreparedPutContentValuesIterable.Builder(storIOSQLite, contentValues)
+                .withPutResolver(putResolver)
+                .useTransaction(true)
+                .prepare()
+                .asRxComletable()
+                .subscribe(testSubscriber);
+
+        testSubscriber.awaitTerminalEvent();
+        testSubscriber.assertNoValues();
+        testSubscriber.assertError(StorIOException.class);
+
+        //noinspection ThrowableResultOfMethodCallIgnored
+        StorIOException expected = (StorIOException) testSubscriber.getOnErrorEvents().get(0);
+
+        IllegalStateException cause = (IllegalStateException) expected.getCause();
+        assertThat(cause).hasMessage("test exception");
+
+        verify(internal).beginTransaction();
+        verify(internal, never()).setTransactionSuccessful();
+        verify(internal).endTransaction();
+
+        verify(storIOSQLite).lowLevel();
+        verify(putResolver).performPut(same(storIOSQLite), any(ContentValues.class));
+        verifyNoMoreInteractions(storIOSQLite, internal, putResolver);
+    }
+
+    @Test
     public void verifyBehaviorInCaseOfExceptionWithoutTransactionBlocking() {
         final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
         final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
@@ -353,4 +427,44 @@ public void verifyBehaviorInCaseOfExceptionWithoutTransactionSingle() {
         verify(putResolver).performPut(same(storIOSQLite), any(ContentValues.class));
         verifyNoMoreInteractions(storIOSQLite, internal, putResolver);
     }
+
+    @Test
+    public void verifyBehaviorInCaseOfExceptionWithoutTransactionCompletable() {
+        final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
+        final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
+
+        //noinspection unchecked
+        final PutResolver<ContentValues> putResolver = mock(PutResolver.class);
+
+        final List<ContentValues> contentValues = singletonList(mock(ContentValues.class));
+
+        when(putResolver.performPut(same(storIOSQLite), any(ContentValues.class)))
+                .thenThrow(new IllegalStateException("test exception"));
+
+        final TestSubscriber<PutResults<ContentValues>> testSubscriber = new TestSubscriber<PutResults<ContentValues>>();
+
+        new PreparedPutContentValuesIterable.Builder(storIOSQLite, contentValues)
+                .withPutResolver(putResolver)
+                .useTransaction(false)
+                .prepare()
+                .asRxComletable()
+                .subscribe(testSubscriber);
+
+        testSubscriber.awaitTerminalEvent();
+        testSubscriber.assertNoValues();
+        testSubscriber.assertError(StorIOException.class);
+
+        //noinspection ThrowableResultOfMethodCallIgnored
+        StorIOException expected = (StorIOException) testSubscriber.getOnErrorEvents().get(0);
+
+        IllegalStateException cause = (IllegalStateException) expected.getCause();
+        assertThat(cause).hasMessage("test exception");
+
+        // Main check of this test
+        verify(internal, never()).endTransaction();
+
+        verify(storIOSQLite).lowLevel();
+        verify(putResolver).performPut(same(storIOSQLite), any(ContentValues.class));
+        verifyNoMoreInteractions(storIOSQLite, internal, putResolver);
+    }
 }
diff --git a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValuesTest.java b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValuesTest.java
index ad5a909..8fa3d50 100644
--- a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValuesTest.java
+++ b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutContentValuesTest.java
@@ -2,6 +2,7 @@
 
 import org.junit.Test;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 
@@ -48,4 +49,18 @@ public void putContentValuesSingle() {
 
         putStub.verifyBehaviorForOneContentValues(putResultSingle);
     }
+
+    @Test
+    public void putContentValuesCompletable() {
+        final PutContentValuesStub putStub = PutContentValuesStub.newPutStubForOneContentValues();
+
+        final Completable completable = putStub.storIOSQLite
+                .put()
+                .contentValues(putStub.contentValues.get(0))
+                .withPutResolver(putStub.putResolver)
+                .prepare()
+                .asRxComletable();
+
+        putStub.verifyBehaviorForOneContentValues(completable);
+    }
 }
diff --git a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutObjectTest.java b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutObjectTest.java
index 8683f69..ec92c74 100644
--- a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutObjectTest.java
+++ b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PreparedPutObjectTest.java
@@ -7,6 +7,7 @@
 import org.junit.experimental.runners.Enclosed;
 import org.junit.runner.RunWith;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.observers.TestSubscriber;
@@ -64,6 +65,20 @@ public void shouldPutObjectWithoutTypeMappingAsSingle() {
 
             putStub.verifyBehaviorForOneObject(putResultSingle);
         }
+
+        @Test
+        public void shouldPutObjectWithoutTypeMappingAsCompetable() {
+            final PutObjectsStub putStub = PutObjectsStub.newPutStubForOneObjectWithoutTypeMapping();
+
+            final Completable completable = putStub.storIOSQLite
+                    .put()
+                    .object(putStub.items.get(0))
+                    .withPutResolver(putStub.putResolver)
+                    .prepare()
+                    .asRxComletable();
+
+            putStub.verifyBehaviorForOneObject(completable);
+        }
     }
 
     public static class WithTypeMapping {
@@ -106,6 +121,19 @@ public void shouldPutObjectWithTypeMappingAsSingle() {
 
             putStub.verifyBehaviorForOneObject(putResultSingle);
         }
+
+        @Test
+        public void shouldPutObjectWithTypeMappingAsCompletable() {
+            final PutObjectsStub putStub = PutObjectsStub.newPutStubForOneObjectWithTypeMapping();
+
+            final Completable completable = putStub.storIOSQLite
+                    .put()
+                    .object(putStub.items.get(0))
+                    .prepare()
+                    .asRxComletable();
+
+            putStub.verifyBehaviorForOneObject(completable);
+        }
     }
 
     public static class TypeMappingError {
@@ -204,5 +232,39 @@ public void shouldThrowExceptionIfNoTypeMappingWasFoundWithoutAffectingDbSingle(
             verify(internal).typeMapping(Object.class);
             verifyNoMoreInteractions(storIOSQLite, internal);
         }
+
+        @Test
+        public void shouldThrowExceptionIfNoTypeMappingWasFoundWithoutAffectingDbCompletable() {
+            final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
+            final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
+
+            when(storIOSQLite.lowLevel()).thenReturn(internal);
+
+            final Object object = new Object();
+
+            final TestSubscriber<PutResult> testSubscriber = new TestSubscriber<PutResult>();
+
+            new PreparedPutObject.Builder<Object>(storIOSQLite, object)
+                    .prepare()
+                    .asRxComletable()
+                    .subscribe(testSubscriber);
+
+            testSubscriber.awaitTerminalEvent();
+            testSubscriber.assertNoValues();
+            testSubscriber.assertError(StorIOException.class);
+
+            //noinspection ThrowableResultOfMethodCallIgnored
+            StorIOException expected = (StorIOException) testSubscriber.getOnErrorEvents().get(0);
+
+            IllegalStateException cause = (IllegalStateException) expected.getCause();
+
+            assertThat(cause).hasMessage("Object does not have type mapping: " +
+                    "object = " + object + ", object.class = " + object.getClass() + ", " +
+                    "db was not affected by this operation, please add type mapping for this type");
+
+            verify(storIOSQLite).lowLevel();
+            verify(internal).typeMapping(Object.class);
+            verifyNoMoreInteractions(storIOSQLite, internal);
+        }
     }
 }
diff --git a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PutContentValuesStub.java b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PutContentValuesStub.java
index a71df8a..6f16f89 100644
--- a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PutContentValuesStub.java
+++ b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PutContentValuesStub.java
@@ -10,6 +10,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.functions.Action1;
@@ -102,6 +103,10 @@ public void call(PutResults<ContentValues> putResults) {
                 .checkBehaviorOfObservable();
     }
 
+    void verifyBehaviorForMultipleContentValues(@NonNull Completable completable) {
+        verifyBehaviorForMultipleContentValues(completable.<PutResults<ContentValues>>toObservable());
+    }
+
     void verifyBehaviorForMultipleContentValues(@NonNull Single<PutResults<ContentValues>> putResultsSingle) {
         new ObservableBehaviorChecker<PutResults<ContentValues>>()
                 .observable(putResultsSingle.toObservable())
@@ -115,6 +120,7 @@ public void call(PutResults<ContentValues> putResults) {
                 .checkBehaviorOfObservable();
     }
 
+
     void verifyBehaviorForOneContentValues(@NonNull PutResult putResult) {
         verifyBehaviorForMultipleContentValues(PutResults.newInstance(singletonMap(contentValues.get(0), putResult)));
     }
@@ -145,6 +151,10 @@ public void call(PutResult putResult) {
                 .checkBehaviorOfObservable();
     }
 
+    void verifyBehaviorForOneContentValues(@NonNull Completable completable) {
+       verifyBehaviorForOneContentValues(completable.<PutResult>toObservable());
+    }
+
     private void verifyTransactionBehavior() {
         if (useTransaction) {
             verify(internal, times(1)).beginTransaction();
diff --git a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PutObjectsStub.java b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PutObjectsStub.java
index 50d3c99..f4f3f72 100644
--- a/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PutObjectsStub.java
+++ b/storio-sqlite/src/test/java/com/pushtorefresh/storio/sqlite/operations/put/PutObjectsStub.java
@@ -15,6 +15,7 @@
 import java.util.List;
 import java.util.Map;
 
+import rx.Completable;
 import rx.Observable;
 import rx.Single;
 import rx.functions.Action1;
@@ -187,6 +188,10 @@ public void call(PutResults<TestItem> testItemPutResults) {
                 .checkBehaviorOfObservable();
     }
 
+    void verifyBehaviorForMultipleObjects(@NonNull Completable completable) {
+        verifyBehaviorForMultipleObjects(completable.<PutResults<TestItem>>toObservable());
+    }
+
     void verifyBehaviorForOneObject(@NonNull PutResult putResult) {
         verifyBehaviorForMultipleObjects(PutResults.newInstance(singletonMap(items.get(0), putResult)));
     }
@@ -217,6 +222,10 @@ public void call(PutResult putResult) {
                 .checkBehaviorOfObservable();
     }
 
+    void verifyBehaviorForOneObject(@NonNull Completable completable) {
+        verifyBehaviorForOneObject(completable.<PutResult>toObservable());
+    }
+
     private void verifyTransactionBehavior() {
         if (useTransaction) {
             verify(internal, times(1)).beginTransaction();
