diff --git a/.travis.yml b/.travis.yml
index a2e3a69..8644191 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -11,5 +11,8 @@ cache:
 jdk:
   - oraclejdk8
 
+script:
+  - TEST_TYPE='unit' ./gradlew check
+
 after_success:
   - ./gradlew jacocoTestReport coveralls
diff --git a/build.gradle b/build.gradle
index b057508..ee44a5e 100644
--- a/build.gradle
+++ b/build.gradle
@@ -11,16 +11,20 @@ apply plugin: 'maven-publish'
 
 group = 'com.filestack'
 sourceCompatibility = 1.7
-version = getVersion()
+version = file(new File('VERSION')).text.trim() // Get version string from VERSION text file
 
-repositories {
-    jcenter()
+// ***************************************** Config ***********************************************
+
+configurations {
+    integTestCompile.extendsFrom testCompile
+    integTestRuntime.extendsFrom testRuntime
+    integTestImplementation.extendsFrom testImplementation
 }
 
 dependencies {
     testImplementation 'junit:junit:4.12' // Testing
     testImplementation 'org.mockito:mockito-core:2.8.47' // Mocking
-    testImplementation 'com.squareup.retrofit2:retrofit-mock:2.3.0' // Testing helpers for Retrofit
+    testImplementation 'com.squareup.retrofit2:retrofit-mock:2.3.0' // Helpers for Retrofit
 
     compile 'com.squareup.okhttp3:okhttp:3.8.0' // Low-level HTTP client
     compile 'com.squareup.retrofit2:retrofit:2.3.0' // High-level HTTP client
@@ -34,36 +38,40 @@ dependencies {
     compile 'io.reactivex.rxjava2:rxjava:2.1.2' // Observable pattern for async methods
 }
 
-
-// ***************************************** General Config ***************************************
-
-checkstyle {
-    toolVersion '8.1'
-}
-
-jacocoTestReport {
-    reports {
-        xml.enabled = true
-        html.enabled = true
-    }
-}
-
 javadoc {
     destinationDir new File("./docs")
     options.optionFiles(new File('./config/javadoc/javadoc.txt'))
 }
 
-// ***************************************** General Config ***************************************
-
+// Publications define artifacts to upload to Bintray
+publishing {
+    publications {
+        Maven(MavenPublication) {
+            from components.java
+            artifact sourcesJar
+            artifact javadocJar
+        }
+    }
+}
 
-// ***************************************** Version Config ***************************************
+repositories {
+    jcenter()
+}
 
-// Get version string from VERSION text file
-def getVersion() {
-    return file(new File('VERSION')).text.trim()
+sourceSets {
+    integTest {
+        java {
+            compileClasspath += main.output + test.output
+            runtimeClasspath += main.output + test.output
+            srcDir file('src/integTest/java')
+        }
+        resources.srcDir file('src/integTest/resources')
+    }
 }
 
-// Create version properties file from VERSION text file
+// ***************************************** Tasks ************************************************
+
+// Output version to version.properties file
 task createProperties(dependsOn: processResources) {
     doLast {
         new File("$buildDir/resources/main/version.properties").withWriter { w ->
@@ -74,28 +82,33 @@ task createProperties(dependsOn: processResources) {
     }
 }
 
-// Add task to build process
-classes {
-    dependsOn createProperties
+// Run integration tests
+task integTest(type: Test) {
+    testClassesDir = sourceSets.integTest.output.classesDir
+    classpath = sourceSets.integTest.runtimeClasspath
+    outputs.upToDateWhen { false }
 }
 
-// ***************************************** Version Config ***************************************
-
+// Create javadoc artifact jar
+task javadocJar(type: Jar, dependsOn: javadoc) {
+    classifier = 'javadoc'
+    from javadoc.destinationDir
+}
 
-// ***************************************** Bintray Config ***************************************
+// Create source artifact jar
+task sourcesJar(type: Jar, dependsOn: classes) {
+    classifier = 'sources'
+    from sourceSets.main.allSource
+}
 
-// Publications define artifacts to upload to Bintray
-publishing {
-    publications {
-        Maven(MavenPublication) {
-            from components.java
-            artifact sourcesJar
-            artifact javadocJar
-        }
-    }
+classes.dependsOn createProperties // Create version.properties as part of build
+integTest.mustRunAfter test // Run integration tests after unit tests
+tasks.withType(Test) { // Put unit and integration test reports in separate directories
+    reports.html.destination = file("${reporting.baseDir}/${name}")
 }
 
-// Bintray publishing config
+// *************************************** Plugin Config ******************************************
+
 bintray {
     user = project.hasProperty('bintrayUser') ? project.property('bintrayUser')
             : System.getenv('BINTRAY_USER')
@@ -127,15 +140,13 @@ bintray {
     }
 }
 
-// Tasks for creating artifact jars
-task sourcesJar(type: Jar, dependsOn: classes) {
-    classifier = 'sources'
-    from sourceSets.main.allSource
+checkstyle {
+    toolVersion '8.1'
 }
 
-task javadocJar(type: Jar, dependsOn: javadoc) {
-    classifier = 'javadoc'
-    from javadoc.destinationDir
+jacocoTestReport {
+    reports {
+        xml.enabled = true
+        html.enabled = true
+    }
 }
-
-// ***************************************** Bintray Config ***************************************
diff --git a/src/main/java/com/filestack/FileLink.java b/src/main/java/com/filestack/FileLink.java
index 668cd74..936e918 100644
--- a/src/main/java/com/filestack/FileLink.java
+++ b/src/main/java/com/filestack/FileLink.java
@@ -6,8 +6,10 @@
 import com.filestack.errors.ResourceNotFoundException;
 import com.filestack.errors.ValidationException;
 import com.filestack.responses.ImageTagResponse;
+import com.filestack.transforms.AvTransform;
 import com.filestack.transforms.ImageTransform;
 import com.filestack.transforms.ImageTransformTask;
+import com.filestack.transforms.tasks.AvTransformOptions;
 import com.filestack.util.FsService;
 import com.filestack.util.Util;
 import com.google.gson.Gson;
@@ -307,6 +309,28 @@ public boolean imageSfw()
     return json.get("sfw").getAsBoolean();
   }
 
+  /**
+   * Creates an {@link AvTransform} object for this file using default storage options.
+   *
+   * @see #avTransform(StorageOptions, AvTransformOptions)
+   */
+  public AvTransform avTransform(AvTransformOptions avOptions) {
+    return avTransform(null, avOptions);
+  }
+
+  /**
+   * Creates an {@link AvTransform} object for this file using custom storage options.
+   * A transformation call isn't made directly by this method.
+   * For both audio and video transformations.
+   *
+   * @param storeOptions options for how to save the file(s) in your storage backend
+   * @param avOptions    options for how ot convert the file
+   * @return {@link AvTransform ImageTransform} instance configured for this file
+   */
+  public AvTransform avTransform(StorageOptions storeOptions, AvTransformOptions avOptions) {
+    return new AvTransform(this, storeOptions, avOptions);
+  }
+
   // Async method wrappers
 
   /**
diff --git a/src/main/java/com/filestack/FilestackClient.java b/src/main/java/com/filestack/FilestackClient.java
index d3d9a2a..12a38df 100644
--- a/src/main/java/com/filestack/FilestackClient.java
+++ b/src/main/java/com/filestack/FilestackClient.java
@@ -88,7 +88,7 @@ public FilestackClient build() {
   /**
    * Upload local file using default storage options.
    *
-   * @see #upload(String, UploadOptions)
+   * @see #upload(String, StorageOptions, boolean)
    */
   public FileLink upload(String pathname)
       throws ValidationException, IOException, PolicySignatureException,
@@ -99,8 +99,20 @@ public FileLink upload(String pathname)
   /**
    * Upload local file using custom storage options.
    *
-   * @param pathname  path to the file, can be local or absolute
-   * @param options   storage options, https://www.filestack.com/docs/rest-api/store
+   * @see #upload(String, StorageOptions, boolean)
+   */
+  public FileLink upload(String pathname, StorageOptions options)
+      throws ValidationException, IOException, PolicySignatureException,
+             InvalidParameterException, InternalException {
+    return upload(pathname, options, true);
+  }
+
+  /**
+   * Upload local file using custom storage and upload options.
+   *
+   * @param pathname    path to the file, can be local or absolute
+   * @param options     storage options, https://www.filestack.com/docs/rest-api/store
+   * @param intelligent intelligent ingestion, improves reliability for bad networks
    * @return new {@link FileLink} referencing file
    * @throws ValidationException       if the pathname doesn't exist or isn't a regular file
    * @throws IOException               if request fails because of network or other IO issue
@@ -108,14 +120,15 @@ public FileLink upload(String pathname)
    * @throws InvalidParameterException if a request parameter is missing or invalid
    * @throws InternalException         if unexpected error occurs
    */
-  public FileLink upload(String pathname, UploadOptions options)
+  public FileLink upload(String pathname, StorageOptions options, boolean intelligent)
       throws ValidationException, IOException, PolicySignatureException,
              InvalidParameterException, InternalException {
+
     if (options == null) {
-      options = new UploadOptions.Builder().build();
+      options = new StorageOptions.Builder().build();
     }
 
-    Upload upload = new Upload(pathname, this, options, fsService, delayBase);
+    Upload upload = new Upload(pathname, options, intelligent, delayBase, this, fsService);
     return upload.run();
   }
 
@@ -124,7 +137,7 @@ public FileLink upload(String pathname, UploadOptions options)
   /**
    * Asynchronously upload local file using default storage options.
    *
-   * @see #upload(String, UploadOptions)
+   * @see #upload(String, StorageOptions, boolean)
    */
   public Single<FileLink> uploadAsync(String pathname) {
     return uploadAsync(pathname, null);
@@ -133,13 +146,24 @@ public Single<FileLink> uploadAsync(String pathname) {
   /**
    * Asynchronously upload local file using custom storage options.
    *
-   * @see #upload(String, UploadOptions)
+   * @see #upload(String, StorageOptions, boolean)
    */
-  public Single<FileLink> uploadAsync(final String pathname, final UploadOptions options) {
+  public Single<FileLink> uploadAsync(final String pathname, final StorageOptions options) {
+    return uploadAsync(pathname, options, true);
+  }
+
+  /**
+   * Asynchronously upload local file using custom storage and upload options.
+   *
+   * @see #upload(String, StorageOptions, boolean)
+   */
+  public Single<FileLink> uploadAsync(final String pathname, final StorageOptions options,
+                                      final boolean intelligent) {
+
     return Single.fromCallable(new Callable<FileLink>() {
       @Override
       public FileLink call() throws Exception {
-        return upload(pathname, options);
+        return upload(pathname, options, intelligent);
       }
     })
         .subscribeOn(Schedulers.io())
diff --git a/src/main/java/com/filestack/StorageOptions.java b/src/main/java/com/filestack/StorageOptions.java
new file mode 100644
index 0000000..9504475
--- /dev/null
+++ b/src/main/java/com/filestack/StorageOptions.java
@@ -0,0 +1,115 @@
+package com.filestack;
+
+import com.filestack.transforms.TransformTask;
+import com.filestack.util.Util;
+import java.util.HashMap;
+import java.util.Map;
+import okhttp3.RequestBody;
+
+/** Configure storage options for uploads and transformation stores. */
+public class StorageOptions {
+  private String access;
+  private Boolean base64Decode;
+  private String container;
+  private String filename;
+  private String location;
+  private String path;
+  private String region;
+
+  public StorageOptions() { }
+
+  /** Get these options as a task. */
+  public TransformTask getAsTask() {
+    TransformTask task = new TransformTask("store");
+    addToTask(task);
+    return task;
+  }
+
+  /** Add these options to an existing task. */
+  public void addToTask(TransformTask task) {
+    task.addOption("access", access);
+    task.addOption("base64decode", base64Decode);
+    task.addOption("container", container);
+    task.addOption("filename", filename);
+    task.addOption("location", location);
+    task.addOption("path", path);
+    task.addOption("region", region);
+  }
+
+  /** Get these options as a part map to use for uploads. */
+  public Map<String, RequestBody> getAsPartMap() {
+    HashMap<String, RequestBody> map = new HashMap<>();
+    addToMap(map, "store_access", access);
+    addToMap(map, "store_container", container);
+    addToMap(map, "store_location", location != null ? location : "s3");
+    addToMap(map, "store_path", path);
+    addToMap(map, "store_region", region);
+    return map;
+  }
+
+  private static void addToMap(Map<String, RequestBody> map, String key, String value) {
+    if (value != null) {
+      map.put(key, Util.createStringPart(value));
+    }
+  }
+
+  public static class Builder {
+    private String access;
+    private Boolean base64Decode;
+    private String container;
+    private String filename;
+    private String location;
+    private String path;
+    private String region;
+
+    public Builder access(String access) {
+      this.access = access;
+      return this;
+    }
+
+    public Builder base64Decode(boolean base64Decode) {
+      this.base64Decode = base64Decode;
+      return this;
+    }
+
+    public Builder container(String container) {
+      this.container = container;
+      return this;
+    }
+
+    public Builder filename(String filename) {
+      this.filename = filename;
+      return this;
+    }
+
+    public Builder location(String location) {
+      this.location = location;
+      return this;
+    }
+
+    public Builder path(String path) {
+      this.path = path;
+      return this;
+    }
+
+    public Builder region(String region) {
+      this.region = region;
+      return this;
+    }
+
+    /**
+     * Builds new {@link StorageOptions}.
+     */
+    public StorageOptions build() {
+      StorageOptions building = new StorageOptions();
+      building.access = access;
+      building.base64Decode = base64Decode;
+      building.container = container;
+      building.filename = filename;
+      building.location = location;
+      building.path = path;
+      building.region = region;
+      return building;
+    }
+  }
+}
diff --git a/src/main/java/com/filestack/UploadOptions.java b/src/main/java/com/filestack/UploadOptions.java
deleted file mode 100644
index e6c4d32..0000000
--- a/src/main/java/com/filestack/UploadOptions.java
+++ /dev/null
@@ -1,107 +0,0 @@
-package com.filestack;
-
-import com.filestack.util.Util;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import okhttp3.RequestBody;
-
-/**
- * Configures options for an upload.
- */
-public class UploadOptions {
-  HashMap<String, RequestBody> map;
-
-  UploadOptions(HashMap<String, RequestBody> map) {
-    this.map = map;
-  }
-
-  public Map<String, RequestBody> getMap() {
-    return map;
-  }
-
-  // Javadoc comments adapted from
-  // https://github.com/filepicker/filestack-uploads/blob/develop/README.md
-
-  /**
-   * Builds new {@link UploadOptions}.
-   */
-  public static class Builder {
-    HashMap<String, RequestBody> map = new HashMap<>();
-
-    /**
-     * Set the location where the file will be stored. For locations other than s3 the file will be
-     * first stored in Filestack's internal S3 bucket and then moved to a proper location.
-     * If empty or not valid the file will be stored in S3 bucket configured for the selected
-     * application (if configured) or in Filestack's internal S3 bucket.
-     *
-     * @param location s3, gcs, dropbox, azure, or rackspace
-     */
-    public Builder location(String location) {
-      map.put("store_location", Util.createStringPart(location));
-      return this;
-    }
-
-    /**
-     * Set an S3 region for the selected S3 bucket. If {@link #container(String)} is provided and
-     * this is empty, the application will try to get the region from database or directly from
-     * Amazon.
-     */
-    public Builder region(String region) {
-      map.put("store_region", Util.createStringPart(region));
-      return this;
-    }
-
-    /** Set the name of the container where the file will be stored. */
-    public Builder container(String container) {
-      map.put("store_container", Util.createStringPart(container));
-      return this;
-    }
-
-    /**
-     * Set the path where the file will be stored. By default, the file is stored at the root of the
-     * container at a unique id, followed by an underscore, followed by the filename. Paths ending
-     * with / will be treated as folders where the files will be stored in a similar way. Ignored
-     * if the file is stored in Filestack's internal S3 bucket.
-     */
-    public Builder path(String path) {
-      map.put("store_path", Util.createStringPart(path));
-      return this;
-    }
-
-    /**
-     * Set if the file should be stored in a way that allows public access going directly to
-     * the underlying file store. If empty or the file is stored in Filestack's internal S3 bucket
-     * it defaults to private.
-     *
-     * @param access private or public
-     */
-    public Builder access(String access) {
-      map.put("store_access", Util.createStringPart(access));
-      return this;
-    }
-
-    /**
-     * Sets if the upload should use Filestack Intelligent Ingestion. Enabled by default.
-     * This must also be enabled on your account to work, if not it will be ignored.
-     */
-    public Builder intelligent(boolean intelligent) {
-      map.put("multipart", Util.createStringPart(Boolean.toString(intelligent)));
-      return this;
-    }
-
-    /**
-     * Create the {@link UploadOptions} instance using the configured values.
-     */
-    public UploadOptions build() {
-      if (!map.containsKey("store_location")) {
-        map.put("store_location", Util.createStringPart("s3"));
-      }
-      if (!map.containsKey("multipart")) {
-        map.put("multipart", Util.createStringPart("true"));
-      }
-      return new UploadOptions(map);
-    }
-  }
-}
diff --git a/src/main/java/com/filestack/transforms/AvTransform.java b/src/main/java/com/filestack/transforms/AvTransform.java
new file mode 100644
index 0000000..fbe5430
--- /dev/null
+++ b/src/main/java/com/filestack/transforms/AvTransform.java
@@ -0,0 +1,113 @@
+package com.filestack.transforms;
+
+import com.filestack.FileLink;
+import com.filestack.StorageOptions;
+import com.filestack.errors.InternalException;
+import com.filestack.errors.InvalidArgumentException;
+import com.filestack.errors.InvalidParameterException;
+import com.filestack.errors.PolicySignatureException;
+import com.filestack.errors.ResourceNotFoundException;
+import com.filestack.transforms.tasks.AvTransformOptions;
+import com.filestack.util.Util;
+import com.google.gson.JsonObject;
+import io.reactivex.Single;
+import io.reactivex.schedulers.Schedulers;
+import java.io.IOException;
+import java.util.concurrent.Callable;
+
+/**
+ * {@link Transform Transform} subclass for audio and video transformations.
+ */
+public class AvTransform extends Transform {
+
+  /**
+   * Constructs a new instance.
+   *
+   * @param fileLink  must point to an existing audio or video resource
+   * @param storeOpts sets how the resulting file(s) are stored, uses defaults if null
+   * @param avOps     sets conversion options
+   */
+  public AvTransform(FileLink fileLink, StorageOptions storeOpts, AvTransformOptions avOps) {
+
+    super(fileLink);
+
+    if (avOps == null) {
+      throw new InvalidArgumentException("AvTransform can't be created without options");
+    }
+
+    if (storeOpts != null) {
+      tasks.add(TransformTask.merge("video_convert", storeOpts.getAsTask(), avOps));
+    } else {
+      tasks.add(avOps);
+    }
+  }
+
+  /**
+   * Gets converted content as a new {@link FileLink}. Starts processing on first call.
+   * Returns null if still processing. Poll this method or use {@link #getFileLinkAsync()}.
+   * If you need other data, such as thumbnails, use {@link Transform#getContentJson()}.
+   *
+   * @return null if processing, new {@link FileLink} if complete
+   * @throws IOException               if request fails because of network or other IO issue
+   * @throws PolicySignatureException  if security is missing or invalid or tagging isn't enabled
+   * @throws ResourceNotFoundException if handle isn't found
+   * @throws InvalidParameterException if handle is malformed
+   * @throws InternalException         if unexpected error occurs
+   */
+  public FileLink getFileLink()
+      throws IOException, PolicySignatureException, ResourceNotFoundException,
+             InvalidParameterException, InternalException {
+
+    JsonObject json = getContentJson();
+    String status = json.get("status").getAsString();
+
+    switch (status) {
+      case "started":
+      case "pending":
+        return null;
+      case "completed":
+        JsonObject data = json.get("data").getAsJsonObject();
+        String url = data.get("url").getAsString();
+        String handle = url.split("/")[3];
+        return new FileLink(apiKey, handle, security);
+      default:
+        throw new InternalException();
+    }
+  }
+
+  // Async method wrappers
+
+  /**
+   * Asynchronously gets converted content as a new {@link FileLink}.
+   * Uses default 10 second polling. Use {@link #getFileLinkAsync(int)} to adjust interval.
+   *
+   * @see #getFileLink()
+   */
+  public Single<FileLink> getFileLinkAsync() {
+    return getFileLinkAsync(10);
+  }
+
+  /**
+   * Asynchronously gets converted content as a new {@link FileLink}.
+   *
+   * @param pollInterval how frequently to poll (in seconds)
+   * @see #getFileLink()
+   */
+  public Single<FileLink> getFileLinkAsync(final int pollInterval) {
+    return Single.fromCallable(new Callable<FileLink>() {
+      @Override
+      public FileLink call() throws Exception {
+        FileLink fileLink = null;
+        while (fileLink == null) {
+          fileLink = getFileLink();
+          if (!Util.isUnitTest()) {
+            Thread.sleep(pollInterval * 1000);
+          }
+        }
+        return fileLink;
+      }
+    })
+        .subscribeOn(Schedulers.io())
+        .observeOn(Schedulers.single());
+  }
+}
diff --git a/src/main/java/com/filestack/transforms/ImageTransform.java b/src/main/java/com/filestack/transforms/ImageTransform.java
index aff905d..d5d30d0 100644
--- a/src/main/java/com/filestack/transforms/ImageTransform.java
+++ b/src/main/java/com/filestack/transforms/ImageTransform.java
@@ -2,12 +2,12 @@
 
 import com.filestack.FileLink;
 import com.filestack.FilestackClient;
+import com.filestack.StorageOptions;
 import com.filestack.errors.InternalException;
 import com.filestack.errors.InvalidParameterException;
 import com.filestack.errors.PolicySignatureException;
 import com.filestack.errors.ResourceNotFoundException;
 import com.filestack.responses.StoreResponse;
-import com.filestack.transforms.tasks.StoreOptions;
 import com.filestack.util.Util;
 import com.google.gson.JsonObject;
 import io.reactivex.Single;
@@ -85,7 +85,7 @@ public FileLink store()
    * Stores the result of a transformation into a new file.
    * @see <a href="https://www.filestack.com/docs/image-transformations/store"></a>
    *
-   * @param storeOptions configure where and how your file is stored
+   * @param storageOptions configure where and how your file is stored
    * @return new {@link FileLink FileLink} pointing to the file
    * @throws IOException               if request fails because of network or other IO issue
    * @throws PolicySignatureException  if security is missing or invalid
@@ -93,14 +93,15 @@ public FileLink store()
    * @throws InvalidParameterException if a request parameter is missing or invalid
    * @throws InternalException         if unexpected error occurs
    */
-  public FileLink store(StoreOptions storeOptions)
+  public FileLink store(StorageOptions storageOptions)
       throws IOException, PolicySignatureException, ResourceNotFoundException,
              InvalidParameterException, InternalException {
 
-    if (storeOptions == null) {
-      storeOptions = new StoreOptions();
+    if (storageOptions == null) {
+      storageOptions = new StorageOptions();
     }
-    addTask(storeOptions);
+
+    tasks.add(storageOptions.getAsTask());
 
     Response<StoreResponse> response;
     String tasksString = getTasksString();
@@ -160,14 +161,14 @@ public Single<FileLink> storeAsync() {
   }
 
   /**
-   * Async, observable version of {@link #store(StoreOptions)}.
+   * Async, observable version of {@link #store(StorageOptions)}.
    * Same exceptions are passed through observable.
    */
-  public Single<FileLink> storeAsync(final StoreOptions storeOptions) {
+  public Single<FileLink> storeAsync(final StorageOptions storageOptions) {
     return Single.fromCallable(new Callable<FileLink>() {
       @Override
       public FileLink call() throws Exception {
-        return store(storeOptions);
+        return store(storageOptions);
       }
     })
         .subscribeOn(Schedulers.io())
diff --git a/src/main/java/com/filestack/transforms/TransformTask.java b/src/main/java/com/filestack/transforms/TransformTask.java
index 0f01adf..3033d5b 100644
--- a/src/main/java/com/filestack/transforms/TransformTask.java
+++ b/src/main/java/com/filestack/transforms/TransformTask.java
@@ -3,6 +3,7 @@
 import com.filestack.errors.InvalidArgumentException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 
 /**
  * Generic transform task object.
@@ -12,7 +13,7 @@ public class TransformTask {
   String name;
   ArrayList<Option> options;
 
-  TransformTask(String name) {
+  public TransformTask(String name) {
     this.name = name;
     this.options = new ArrayList<>();
   }
@@ -47,14 +48,18 @@ public void addOption(String key, Object value) {
 
     String valueString;
 
+    // If value is a an array (not a Collection)
     if (value.getClass().isArray()) {
       valueString = Arrays.toString((Object[]) value);
     } else {
       valueString = value.toString();
     }
 
-    // Remove spaces between array items
-    valueString = valueString.replace(" ", "");
+    // Remove spaces between array or Collection items
+    if (value.getClass().isArray() || value instanceof Collection) {
+      valueString = valueString.replace(", ", ",");
+    }
+
     options.add(new Option(key, valueString));
   }
 
@@ -70,4 +75,18 @@ public String toString() {
     stringBuilder.deleteCharAt(stringBuilder.length() - 1);
     return stringBuilder.toString();
   }
+
+  /**
+   * Merges options from multiple tasks and returns a new task with combined options.
+   * Does not account for duplicate options.
+   */
+  public static TransformTask merge(String newName, TransformTask... tasks) {
+    ArrayList<Option> options = new ArrayList<>();
+    for (TransformTask task : tasks) {
+      options.addAll(task.options);
+    }
+    TransformTask newTask = new TransformTask(newName);
+    newTask.options = options;
+    return newTask;
+  }
 }
diff --git a/src/main/java/com/filestack/transforms/tasks/AvTransformOptions.java b/src/main/java/com/filestack/transforms/tasks/AvTransformOptions.java
new file mode 100644
index 0000000..2e398b9
--- /dev/null
+++ b/src/main/java/com/filestack/transforms/tasks/AvTransformOptions.java
@@ -0,0 +1,220 @@
+package com.filestack.transforms.tasks;
+
+import com.filestack.transforms.AvTransform;
+import com.filestack.transforms.TransformTask;
+
+/**
+ * Configures conversion settings for {@link AvTransform}.
+ */
+public class AvTransformOptions extends TransformTask {
+
+  AvTransformOptions() {
+    super("video_convert");
+  }
+
+  public static class Builder {
+    // For audio and video
+    private Boolean force;
+    private Integer audioBitrate;
+    private Integer audioChannels;
+    private Integer audioSampleRate;
+    private Integer[] clipLength;
+    private Integer[] clipOffset;
+    private String ext;
+    private String filename;
+    private String preset;
+    private String title;
+
+    // For video only
+    private Boolean twoPass;
+    private Boolean upscale;
+    private Integer fps;
+    private Integer height;
+    private Integer keyframeInt;
+    private Integer videoBitrate;
+    private Integer watermarkBottom;
+    private Integer watermarkHeight;
+    private Integer watermarkLeft;
+    private Integer watermarkRight;
+    private Integer watermarkTop;
+    private Integer watermarkWidth;
+    private Integer width;
+    private String aspectMode;
+    private String watermarkUrl;
+
+    // For audio and video
+
+    public Builder force(boolean force) {
+      this.force = force;
+      return this;
+    }
+
+    public Builder audioBitrate(int audioBitrate) {
+      this.audioBitrate = audioBitrate;
+      return this;
+    }
+
+    public Builder audioChannels(int audioChannels) {
+      this.audioChannels = audioChannels;
+      return this;
+    }
+
+    public Builder audioSampleRate(int audioSampleRate) {
+      this.audioSampleRate = audioSampleRate;
+      return this;
+    }
+
+    public Builder clipLength(int hour, int min, int sec) {
+      this.clipLength = new Integer[]{hour, min, sec};
+      return this;
+    }
+
+    public Builder clipOffset(int hour, int min, int sec) {
+      this.clipOffset = new Integer[]{hour, min, sec};
+      return this;
+    }
+
+    public Builder ext(String ext) {
+      this.ext = ext;
+      return this;
+    }
+
+    public Builder filename(String filename) {
+      this.filename = filename;
+      return this;
+    }
+
+    public Builder preset(String preset) {
+      this.preset = preset;
+      return this;
+    }
+
+    public Builder title(String title) {
+      this.title = title;
+      return this;
+    }
+
+    // For video only
+
+    public Builder twoPass(boolean twoPass) {
+      this.twoPass = twoPass;
+      return this;
+    }
+
+    public Builder upscale(boolean upscale) {
+      this.upscale = upscale;
+      return this;
+    }
+
+    public Builder fps(int fps) {
+      this.fps = fps;
+      return this;
+    }
+
+    public Builder height(int height) {
+      this.height = height;
+      return this;
+    }
+
+    public Builder keyframeInt(int keyframeInt) {
+      this.keyframeInt = keyframeInt;
+      return this;
+    }
+
+    public Builder videoBitrate(int videoBitrate) {
+      this.videoBitrate = videoBitrate;
+      return this;
+    }
+
+    public Builder watermarkBottom(int watermarkBottom) {
+      this.watermarkBottom = watermarkBottom;
+      return this;
+    }
+
+    public Builder watermarkHeight(int watermarkHeight) {
+      this.watermarkHeight = watermarkHeight;
+      return this;
+    }
+
+    public Builder watermarkLeft(int watermarkLeft) {
+      this.watermarkLeft = watermarkLeft;
+      return this;
+    }
+
+    public Builder watermarkRight(int watermarkRight) {
+      this.watermarkRight = watermarkRight;
+      return this;
+    }
+
+    public Builder watermarkTop(int watermarkTop) {
+      this.watermarkTop = watermarkTop;
+      return this;
+    }
+
+    public Builder watermarkWidth(int watermarkWidth) {
+      this.watermarkWidth = watermarkWidth;
+      return this;
+    }
+
+    public Builder width(int width) {
+      this.width = width;
+      return this;
+    }
+
+    public Builder aspectMode(String aspectMode) {
+      this.aspectMode = aspectMode;
+      return this;
+    }
+
+    public Builder watermarkUrl(String watermarkUrl) {
+      this.watermarkUrl = watermarkUrl;
+      return this;
+    }
+
+    /**
+     * Create the {@link AvTransformOptions} using the configured values.
+     */
+    public AvTransformOptions build() {
+      AvTransformOptions options = new AvTransformOptions();
+
+      // For audio and video
+      options.addOption("force", force);
+      options.addOption("audio_bitrate", audioBitrate);
+      options.addOption("audio_channels", audioChannels);
+      options.addOption("audio_sample_rate", audioSampleRate);
+      if (clipLength != null) {
+        options.addOption("clip_length", String.format("%02d:%02d:%02d",
+            clipLength[0], clipLength[1], clipLength[2]));
+      }
+      if (clipOffset != null) {
+        options.addOption("clip_offset", String.format("%02d:%02d:%02d",
+            clipOffset[0], clipOffset[1], clipOffset[2]));
+      }
+      if (ext != null) {
+        options.addOption("extname", ext.startsWith(".") ? ext : "." + ext);
+      }
+      options.addOption("filename", filename);
+      options.addOption("preset", preset);
+      options.addOption("title", title);
+
+      // For video only
+      options.addOption("two_pass", twoPass);
+      options.addOption("upscale", upscale);
+      options.addOption("fps", fps);
+      options.addOption("height", height);
+      options.addOption("keyframe_interval", keyframeInt);
+      options.addOption("video_bitrate", videoBitrate);
+      options.addOption("watermark_bottom", watermarkBottom);
+      options.addOption("watermark_height", watermarkHeight);
+      options.addOption("watermark_left", watermarkLeft);
+      options.addOption("watermark_right", watermarkRight);
+      options.addOption("watermark_top", watermarkTop);
+      options.addOption("watermark_width", watermarkWidth);
+      options.addOption("width", width);
+      options.addOption("aspect_mode", aspectMode);
+      options.addOption("watermark_url", watermarkUrl);
+
+      return options;
+    }
+  }
+}
diff --git a/src/main/java/com/filestack/transforms/tasks/FileTypeConversionTask.java b/src/main/java/com/filestack/transforms/tasks/FileTypeTask.java
similarity index 51%
rename from src/main/java/com/filestack/transforms/tasks/FileTypeConversionTask.java
rename to src/main/java/com/filestack/transforms/tasks/FileTypeTask.java
index 3cc9f0a..507a430 100644
--- a/src/main/java/com/filestack/transforms/tasks/FileTypeConversionTask.java
+++ b/src/main/java/com/filestack/transforms/tasks/FileTypeTask.java
@@ -2,87 +2,87 @@
 
 import com.filestack.transforms.ImageTransformTask;
 
-public class FileTypeConversionTask extends ImageTransformTask {
+public class FileTypeTask extends ImageTransformTask {
 
-  FileTypeConversionTask() {
+  FileTypeTask() {
     super("output");
   }
 
   public static class Builder {
-    private FileTypeConversionTask fileTypeConversionTask;
+    private FileTypeTask fileTypeTask;
 
     public Builder() {
-      this.fileTypeConversionTask = new FileTypeConversionTask();
+      this.fileTypeTask = new FileTypeTask();
     }
 
     public Builder format(String format) {
-      fileTypeConversionTask.addOption("format", format);
+      fileTypeTask.addOption("format", format);
       return this;
     }
 
     public Builder background(String background) {
-      fileTypeConversionTask.addOption("background", background);
+      fileTypeTask.addOption("background", background);
       return this;
     }
 
     public Builder page(int page) {
-      fileTypeConversionTask.addOption("page", page);
+      fileTypeTask.addOption("page", page);
       return this;
     }
 
     public Builder density(int density) {
-      fileTypeConversionTask.addOption("density", density);
+      fileTypeTask.addOption("density", density);
       return this;
     }
 
     public Builder compress(boolean compress) {
-      fileTypeConversionTask.addOption("compress", compress);
+      fileTypeTask.addOption("compress", compress);
       return this;
     }
 
     public Builder quality(int quality) {
-      fileTypeConversionTask.addOption("quality", quality);
+      fileTypeTask.addOption("quality", quality);
       return this;
     }
 
     /** For "input" option. */
     public Builder quality(String quality) {
-      fileTypeConversionTask.addOption("quality", quality);
+      fileTypeTask.addOption("quality", quality);
       return this;
     }
 
     public Builder strip(boolean strip) {
-      fileTypeConversionTask.addOption("strip", strip);
+      fileTypeTask.addOption("strip", strip);
       return this;
     }
 
     public Builder colorSpace(String colorSpace) {
-      fileTypeConversionTask.addOption("colorspace", colorSpace);
+      fileTypeTask.addOption("colorspace", colorSpace);
       return this;
     }
 
     public Builder secure(boolean secure) {
-      fileTypeConversionTask.addOption("secure", secure);
+      fileTypeTask.addOption("secure", secure);
       return this;
     }
 
     public Builder docInfo(boolean docInfo) {
-      fileTypeConversionTask.addOption("docinfo", docInfo);
+      fileTypeTask.addOption("docinfo", docInfo);
       return this;
     }
 
     public Builder pageFormat(String pageFormat) {
-      fileTypeConversionTask.addOption("pageformat", pageFormat);
+      fileTypeTask.addOption("pageformat", pageFormat);
       return this;
     }
 
     public Builder pageOrientation(String pageOrientation) {
-      fileTypeConversionTask.addOption("pageorientation", pageOrientation);
+      fileTypeTask.addOption("pageorientation", pageOrientation);
       return this;
     }
 
-    public FileTypeConversionTask build() {
-      return fileTypeConversionTask;
+    public FileTypeTask build() {
+      return fileTypeTask;
     }
   }
 }
diff --git a/src/main/java/com/filestack/transforms/tasks/StoreOptions.java b/src/main/java/com/filestack/transforms/tasks/StoreOptions.java
deleted file mode 100644
index c6e2cf7..0000000
--- a/src/main/java/com/filestack/transforms/tasks/StoreOptions.java
+++ /dev/null
@@ -1,58 +0,0 @@
-package com.filestack.transforms.tasks;
-
-import com.filestack.transforms.ImageTransformTask;
-
-public class StoreOptions extends ImageTransformTask {
-
-  // Constructor left public because this task can be used with default options
-  public StoreOptions() {
-    super("store");
-  }
-
-  public static class Builder {
-    private StoreOptions storeOptions;
-
-    public Builder() {
-      this.storeOptions = new StoreOptions();
-    }
-
-    public Builder filename(String filename) {
-      storeOptions.addOption("filename", filename);
-      return this;
-    }
-
-    public Builder location(String location) {
-      storeOptions.addOption("location", location);
-      return this;
-    }
-
-    public Builder path(String path) {
-      storeOptions.addOption("path", path);
-      return this;
-    }
-
-    public Builder container(String container) {
-      storeOptions.addOption("container", container);
-      return this;
-    }
-
-    public Builder region(String region) {
-      storeOptions.addOption("region", region);
-      return this;
-    }
-
-    public Builder access(String access) {
-      storeOptions.addOption("access", access);
-      return this;
-    }
-
-    public Builder base64Decode(boolean base64Decode) {
-      storeOptions.addOption("base64decode", base64Decode);
-      return this;
-    }
-
-    public StoreOptions build() {
-      return storeOptions;
-    }
-  }
-}
diff --git a/src/main/java/com/filestack/util/RetryNetworkFunc.java b/src/main/java/com/filestack/util/RetryNetworkFunc.java
index d3b82b1..28ad2dc 100644
--- a/src/main/java/com/filestack/util/RetryNetworkFunc.java
+++ b/src/main/java/com/filestack/util/RetryNetworkFunc.java
@@ -99,7 +99,7 @@ public void onServerFail(int retries) {
    * @return new count value
    */
   private int sleep(int count) {
-    if (delayBase > 0) {
+    if (!Util.isUnitTest()) {
       try {
         Thread.sleep((long) Math.pow(delayBase, count) * 1000);
       } catch (InterruptedException e) {
diff --git a/src/main/java/com/filestack/util/Upload.java b/src/main/java/com/filestack/util/Upload.java
index 638f67d..49bbc0c 100644
--- a/src/main/java/com/filestack/util/Upload.java
+++ b/src/main/java/com/filestack/util/Upload.java
@@ -3,7 +3,7 @@
 import com.filestack.FileLink;
 import com.filestack.FilestackClient;
 import com.filestack.Security;
-import com.filestack.UploadOptions;
+import com.filestack.StorageOptions;
 import com.filestack.errors.InternalException;
 import com.filestack.errors.InvalidParameterException;
 import com.filestack.errors.PolicySignatureException;
@@ -51,30 +51,19 @@ public class Upload {
   private String[] etags;
 
   /**
-   * Construct an instance using global {@link FsUploadService singleton} and default delay.
-   *
-   * @param pathname path to the file to upload
-   * @param fsClient client used to make this upload
-   * @param options  for how to store the file
-   * @throws ValidationException if the pathname doesn't exist or isn't a regular file
-   */
-  public Upload(String pathname, FilestackClient fsClient, UploadOptions options)
-      throws ValidationException {
-    this(pathname, fsClient, options, new FsService(), 2);
-  }
-
-  /**
-   * Construct an instance using custom {@link FsUploadService singleton} and delay.
+   * Constructs a new instance. Must call {@link #run()} to actually perform the upload.
    *
    * @param pathname        for the file to upload
-   * @param fsClient        client used to make this upload
    * @param options         for storing the file
-   * @param fsService client to make Filestack API calls
+   * @param intelligent     intelligent ingestion, improves reliability for bad networks
    * @param delayBase       base for exponential backoff, delay (seconds) == base ^ retryCount
+   * @param fsClient        client used to make this upload
+   * @param fsService       client to make Filestack API calls
+   *
    * @throws ValidationException if the pathname doesn't exist or isn't a regular file
    */
-  public Upload(String pathname, FilestackClient fsClient, UploadOptions options,
-                FsService fsService, int delayBase)
+  public Upload(String pathname, StorageOptions options, boolean intelligent,
+                int delayBase, FilestackClient fsClient, FsService fsService)
       throws ValidationException {
 
     this.filepath = pathname;
@@ -85,7 +74,11 @@ public Upload(String pathname, FilestackClient fsClient, UploadOptions options,
     // Setup base parameters
     baseParams = new HashMap<>();
     baseParams.put("apikey", Util.createStringPart(fsClient.getApiKey()));
-    baseParams.putAll(options.getMap());
+    baseParams.putAll(options.getAsPartMap());
+
+    if (intelligent) {
+      baseParams.put("multipart", Util.createStringPart("true"));
+    }
 
     File file = Util.createReadFile(pathname);
 
diff --git a/src/main/java/com/filestack/util/Util.java b/src/main/java/com/filestack/util/Util.java
index adfcbfa..7ef98e4 100644
--- a/src/main/java/com/filestack/util/Util.java
+++ b/src/main/java/com/filestack/util/Util.java
@@ -12,6 +12,7 @@
 import java.util.Properties;
 import okhttp3.MultipartBody;
 import okhttp3.RequestBody;
+import okio.Buffer;
 import retrofit2.Response;
 
 /**
@@ -48,6 +49,15 @@ public static RequestBody createStringPart(String content) {
     return RequestBody.create(MultipartBody.FORM, content);
   }
 
+  /**
+   * Converts {@link RequestBody} to String.
+   */
+  public static String partToString(RequestBody body) throws IOException {
+    Buffer buffer = new Buffer();
+    body.writeTo(buffer);
+    return buffer.readUtf8();
+  }
+
   /**
    * Checks responses from any of the Filestack APIs.
    * Throws an appropriate exception based on the HTTP status code.
@@ -149,4 +159,9 @@ public static File createReadFile(String pathname) throws ValidationException {
 
     return file;
   }
+
+  public static boolean isUnitTest() {
+    String env = System.getenv("TEST_TYPE");
+    return env != null && env.equals("unit");
+  }
 }
diff --git a/src/test/java/com/filestack/TestFilestackClient.java b/src/test/java/com/filestack/TestFilestackClient.java
index 50bf049..0c43e3b 100644
--- a/src/test/java/com/filestack/TestFilestackClient.java
+++ b/src/test/java/com/filestack/TestFilestackClient.java
@@ -161,7 +161,6 @@ public void testUpload() throws Exception {
         .build();
 
     Path path = createRandomFile(10 * 1024 * 1024);
-    UploadOptions options = new UploadOptions.Builder().build();
 
     Assert.assertEquals("handle", client.upload(path.toString()).getHandle());
 
diff --git a/src/test/java/com/filestack/TestStorageOptions.java b/src/test/java/com/filestack/TestStorageOptions.java
new file mode 100644
index 0000000..1a65372
--- /dev/null
+++ b/src/test/java/com/filestack/TestStorageOptions.java
@@ -0,0 +1,63 @@
+package com.filestack;
+
+import com.filestack.util.Util;
+import java.io.IOException;
+import java.util.Map;
+import okhttp3.RequestBody;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestStorageOptions {
+
+  @Test
+  public void testGetTask() {
+    String correct = "store="
+        + "access:private,"
+        + "base64decode:false,"
+        + "container:some_bucket,"
+        + "filename:some_file.txt,"
+        + "location:S3,"
+        + "path:/some/path/,"
+        + "region:us-east-1";
+
+    StorageOptions options = new StorageOptions.Builder()
+        .filename("some_file.txt")
+        .location("S3")
+        .path("/some/path/")
+        .container("some_bucket")
+        .region("us-east-1")
+        .access("private")
+        .base64Decode(false)
+        .build();
+
+    Assert.assertEquals(correct, options.getAsTask().toString());
+  }
+
+  @Test
+  public void testGetPartMap() throws IOException {
+    StorageOptions options = new StorageOptions.Builder()
+        .access("<access>")
+        .container("<container>")
+        .location("<location>")
+        .path("<path>")
+        .region("<region>")
+        .build();
+
+    Map<String, RequestBody> map = options.getAsPartMap();
+
+    Assert.assertEquals("<access>", Util.partToString(map.get("store_access")));
+    Assert.assertEquals("<container>", Util.partToString(map.get("store_container")));
+    Assert.assertEquals("<location>", Util.partToString(map.get("store_location")));
+    Assert.assertEquals("<path>", Util.partToString(map.get("store_path")));
+    Assert.assertEquals("<region>", Util.partToString(map.get("store_region")));
+  }
+
+  @Test
+  public void testGetPartMapLocationDefault() throws Exception {
+    StorageOptions options = new StorageOptions();
+
+    Map<String, RequestBody> map = options.getAsPartMap();
+
+    Assert.assertEquals("s3", Util.partToString(map.get("store_location")));
+  }
+}
diff --git a/src/test/java/com/filestack/TestUploadOptions.java b/src/test/java/com/filestack/TestUploadOptions.java
deleted file mode 100644
index 03dc0a7..0000000
--- a/src/test/java/com/filestack/TestUploadOptions.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package com.filestack;
-
-import java.util.Map;
-import okhttp3.RequestBody;
-import org.junit.Assert;
-import org.junit.Test;
-
-public class TestUploadOptions {
-
-  @Test
-  public void testBuildingDefaults() {
-    UploadOptions options = new UploadOptions.Builder()
-        .region("<region>")
-        .container("<container>")
-        .path("<path>")
-        .access("<access>")
-        .build();
-
-    Map<String, RequestBody> map = options.getMap();
-
-    Assert.assertNotNull(map.get("store_location"));
-    Assert.assertNotNull(map.get("store_region"));
-    Assert.assertNotNull(map.get("store_container"));
-    Assert.assertNotNull(map.get("store_path"));
-    Assert.assertNotNull(map.get("store_access"));
-    Assert.assertNotNull(map.get("multipart"));
-  }
-
-  @Test
-  public void testBuildingComplete() {
-    UploadOptions options = new UploadOptions.Builder()
-        .location("<location>")
-        .region("<region>")
-        .container("<container>")
-        .path("<path>")
-        .access("<access>")
-        .intelligent(true)
-        .build();
-
-    Map<String, RequestBody> map = options.getMap();
-
-    Assert.assertNotNull(map.get("store_location"));
-    Assert.assertNotNull(map.get("store_region"));
-    Assert.assertNotNull(map.get("store_container"));
-    Assert.assertNotNull(map.get("store_path"));
-    Assert.assertNotNull(map.get("store_access"));
-    Assert.assertNotNull(map.get("multipart"));
-  }
-}
diff --git a/src/test/java/com/filestack/transforms/TestAvTransform.java b/src/test/java/com/filestack/transforms/TestAvTransform.java
new file mode 100644
index 0000000..2259f70
--- /dev/null
+++ b/src/test/java/com/filestack/transforms/TestAvTransform.java
@@ -0,0 +1,108 @@
+package com.filestack.transforms;
+
+import com.filestack.FileLink;
+import com.filestack.StorageOptions;
+import com.filestack.errors.InternalException;
+import com.filestack.errors.InvalidArgumentException;
+import com.filestack.transforms.tasks.AvTransformOptions;
+import com.filestack.util.FsService;
+import okhttp3.MediaType;
+import okhttp3.ResponseBody;
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import retrofit2.Call;
+import retrofit2.mock.Calls;
+
+public class TestAvTransform {
+
+  @Test(expected = InvalidArgumentException.class)
+  public void testConstructorException() {
+    FileLink fileLink = new FileLink("apiKey", "handle");
+    fileLink.avTransform(null);
+  }
+
+  @Test
+  public void testConstructorNoStoreOpts() {
+    AvTransformOptions avOptions = new AvTransformOptions.Builder()
+        .preset("mp4")
+        .build();
+
+    FileLink fileLink = new FileLink("apiKey", "handle");
+    TransformTask task = fileLink.avTransform(avOptions).tasks.get(0);
+
+    Assert.assertEquals("video_convert=preset:mp4", task.toString());
+  }
+
+  @Test
+  public void testConstructorStoreOpts() {
+    StorageOptions storageOptions = new StorageOptions.Builder()
+        .container("some-bucket")
+        .build();
+
+    AvTransformOptions avOptions = new AvTransformOptions.Builder()
+        .preset("mp4")
+        .build();
+
+    FileLink fileLink = new FileLink("apiKey", "handle");
+    TransformTask task = fileLink.avTransform(storageOptions, avOptions).tasks.get(0);
+
+    Assert.assertEquals("video_convert=container:some-bucket,preset:mp4", task.toString());
+  }
+
+  @Test
+  public void testGetFilelink() throws Exception {
+    FsService mockFsService = Mockito.mock(FsService.class);
+
+    Mockito
+        .doAnswer(new Answer() {
+          @Override
+          public Call<ResponseBody> answer(InvocationOnMock invocation) throws Throwable {
+            boolean ready = invocation.getArgument(1).equals("ready");
+            String json = "{'status':" + (ready ? "'completed'" : "'pending'") + ","
+                + "'data': {'url': 'https://cdn.filestackcontent.com/handle'}}";
+            MediaType mediaType = MediaType.parse("application/json");
+            return Calls.response(ResponseBody.create(mediaType, json));
+          }
+        })
+        .when(mockFsService)
+        .transform(Mockito.anyString(), Mockito.anyString());
+
+    FileLink.Builder builder = new FileLink.Builder().apiKey("apiKey").service(mockFsService);
+
+    FileLink ready = builder.handle("ready").build();
+    FileLink pending = builder.handle("pending").build();
+
+    AvTransformOptions avOptions = new AvTransformOptions.Builder().preset("mp4").build();
+
+    FileLink converted = ready.avTransform(avOptions).getFileLink();
+    Assert.assertEquals("handle", converted.getHandle());
+    Assert.assertNull(pending.avTransform(avOptions).getFileLink());
+  }
+
+  @Test(expected = InternalException.class)
+  public void testGetFilelinkFail() throws Exception {
+    FsService mockFsService = Mockito.mock(FsService.class);
+
+    String json = "{'status':'failed'}";
+    MediaType mediaType = MediaType.parse("application/json");
+    ResponseBody responseBody = ResponseBody.create(mediaType, json);
+
+    Mockito
+        .doReturn(Calls.response(responseBody))
+        .when(mockFsService)
+        .transform("video_convert=preset:mp4", "handle");
+
+    FileLink fileLink = new FileLink.Builder()
+        .apiKey("apiKey")
+        .handle("handle")
+        .service(mockFsService)
+        .build();
+
+    AvTransformOptions avOptions = new AvTransformOptions.Builder().preset("mp4").build();
+
+    fileLink.avTransform(avOptions).getFileLink();
+  }
+}
diff --git a/src/test/java/com/filestack/transforms/TestTransformTask.java b/src/test/java/com/filestack/transforms/TestTransformTask.java
index bd6ee6b..3b789c7 100644
--- a/src/test/java/com/filestack/transforms/TestTransformTask.java
+++ b/src/test/java/com/filestack/transforms/TestTransformTask.java
@@ -51,4 +51,24 @@ public void testOptionNullValue() {
     transformTask.addOption("key", null);
     Assert.assertEquals(0, transformTask.options.size());
   }
+  
+  @Test
+  public void testMerge() {
+    TransformTask first = new TransformTask("first");
+    TransformTask second = new TransformTask("second");
+    TransformTask third = new TransformTask("third");
+
+    first.addOption("option1", "value1");
+    second.addOption("option2", "value2");
+    third.addOption("option3", "value3");
+
+    String correct = "merged="
+        + "option1:value1,"
+        + "option2:value2,"
+        + "option3:value3";
+
+    TransformTask merged = TransformTask.merge("merged", first, second, third);
+
+    Assert.assertEquals(correct, merged.toString());
+  }
 }
diff --git a/src/test/java/com/filestack/transforms/tasks/TestAvTransformOptions.java b/src/test/java/com/filestack/transforms/tasks/TestAvTransformOptions.java
new file mode 100644
index 0000000..dfd8699
--- /dev/null
+++ b/src/test/java/com/filestack/transforms/tasks/TestAvTransformOptions.java
@@ -0,0 +1,87 @@
+package com.filestack.transforms.tasks;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestAvTransformOptions {
+
+  @Test
+  public void testToStringAll() {
+    String correct = "video_convert="
+
+        // For audio and video
+        + "force:true,"
+        + "audio_bitrate:256,"
+        + "audio_channels:2,"
+        + "audio_sample_rate:44100,"
+        + "clip_length:00:01:00,"
+        + "clip_offset:00:00:30,"
+        + "extname:.mp4,"
+        + "filename:some_filename,"
+        + "preset:h264,"
+        + "title:Some Title,"
+
+        // For video only
+        + "two_pass:true,"
+        + "upscale:false,"
+        + "fps:24,"
+        + "height:720,"
+        + "keyframe_interval:250,"
+        + "video_bitrate:4096,"
+        + "watermark_bottom:50,"
+        + "watermark_height:300,"
+        + "watermark_left:50,"
+        + "watermark_right:50,"
+        + "watermark_top:50,"
+        + "watermark_width:300,"
+        + "width:1080,"
+        + "aspect_mode:pad,"
+        + "watermark_url:https://example.com/image.png";
+
+    AvTransformOptions options = new AvTransformOptions.Builder()
+        .preset("h264")
+        .force(true)
+        .width(1080)
+        .height(720)
+        .title("Some Title")
+        .ext("mp4")
+        .filename("some_filename")
+        .upscale(false)
+        .aspectMode("pad")
+        .twoPass(true)
+        .videoBitrate(4096)
+        .fps(24)
+        .keyframeInt(250)
+        .audioBitrate(256)
+        .audioSampleRate(44100)
+        .audioChannels(2)
+        .clipLength(0, 1, 0)
+        .clipOffset(0, 0, 30)
+        .watermarkUrl("https://example.com/image.png")
+        .watermarkTop(50)
+        .watermarkBottom(50)
+        .watermarkLeft(50)
+        .watermarkRight(50)
+        .watermarkWidth(300)
+        .watermarkHeight(300)
+        .build();
+
+    Assert.assertEquals(correct, options.toString());
+  }
+
+  @Test
+  public void testToStringNone() {
+    String correct = "video_convert";
+    AvTransformOptions options = new AvTransformOptions.Builder().build();
+    Assert.assertEquals(correct, options.toString());
+  }
+
+  @Test
+  public void testToStringExt() {
+    String correct = "video_convert=extname:.mp4";
+    AvTransformOptions options = new AvTransformOptions.Builder().ext(".mp4").build();
+    Assert.assertEquals(correct, options.toString());
+    options = new AvTransformOptions.Builder().ext("mp4").build();
+    Assert.assertEquals(correct, options.toString());
+  }
+}
diff --git a/src/test/java/com/filestack/transforms/tasks/TestFileTypeConversionTask.java b/src/test/java/com/filestack/transforms/tasks/TestFileTypeTask.java
similarity index 87%
rename from src/test/java/com/filestack/transforms/tasks/TestFileTypeConversionTask.java
rename to src/test/java/com/filestack/transforms/tasks/TestFileTypeTask.java
index ccf3b8c..54b2aa2 100644
--- a/src/test/java/com/filestack/transforms/tasks/TestFileTypeConversionTask.java
+++ b/src/test/java/com/filestack/transforms/tasks/TestFileTypeTask.java
@@ -4,7 +4,7 @@
 import org.junit.Assert;
 import org.junit.Test;
 
-public class TestFileTypeConversionTask {
+public class TestFileTypeTask {
 
   @Test
   public void testToString() {
@@ -22,7 +22,7 @@ public void testToString() {
         + "pageformat:legal,"
         + "pageorientation:landscape";
 
-    TransformTask task = new FileTypeConversionTask.Builder()
+    TransformTask task = new FileTypeTask.Builder()
         .format("png")
         .background("white")
         .page(4)
@@ -47,7 +47,7 @@ public void testToStringQualityInput() {
     String correct = "output="
         + "quality:input";
 
-    TransformTask task = new FileTypeConversionTask.Builder()
+    TransformTask task = new FileTypeTask.Builder()
         .quality("input")
         .build();
 
diff --git a/src/test/java/com/filestack/transforms/tasks/TestStoreOptions.java b/src/test/java/com/filestack/transforms/tasks/TestStoreOptions.java
deleted file mode 100644
index 467e88a..0000000
--- a/src/test/java/com/filestack/transforms/tasks/TestStoreOptions.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package com.filestack.transforms.tasks;
-
-import static org.junit.Assert.assertTrue;
-
-import com.filestack.transforms.TransformTask;
-import org.junit.Test;
-
-public class TestStoreOptions {
-
-  @Test
-  public void testToString() {
-    String correct = "store="
-        + "filename:some_file.txt,"
-        + "location:S3,"
-        + "path:/some/path/,"
-        + "container:some_bucket,"
-        + "region:us-east-1,"
-        + "access:private,"
-        + "base64decode:false";
-
-    TransformTask task = new StoreOptions.Builder()
-        .filename("some_file.txt")
-        .location("S3")
-        .path("/some/path/")
-        .container("some_bucket")
-        .region("us-east-1")
-        .access("private")
-        .base64Decode(false)
-        .build();
-
-    String output = task.toString();
-
-    String message = String.format("Task string malformed\nCorrect: %s\nOutput: %s",
-        correct, output);
-    assertTrue(message, output.equals(correct));
-  }
-}