diff --git a/js/hatrac.js b/js/hatrac.js
index 4a29ed87..dd12d5a3 100644
--- a/js/hatrac.js
+++ b/js/hatrac.js
@@ -193,6 +193,7 @@ var ERMrest = (function(module) {
 })(ERMrest || {});
 
 var ERMrest = (function(module) {
+    var FILENAME_REGEXP = /[^a-zA-Z0-9_.-]/ig;
 
     var allowedHttpErrors = [500, 503, 408, 401];
 
@@ -310,6 +311,7 @@ var ERMrest = (function(module) {
 
         this.http = this.reference._server.http;
 
+        this.updateDispositionOnly = false;
         this.isPaused = false;
         this.otherInfo = otherInfo;
 
@@ -430,6 +432,7 @@ var ERMrest = (function(module) {
             var headers = module.getResponseHeader(response);
             var md5 = headers["content-md5"];
             var length = headers["content-length"];
+            var contentDisposition = headers["content-disposition"];
 
             // If the file is not same, then simply resolve the promise without setting completed and jobDone
             if ((md5 != self.hash.md5_base64) || (length != self.file.size)) {
@@ -437,6 +440,18 @@ var ERMrest = (function(module) {
                 return;
             }
 
+            // hatrac only supports `filename*=UTF-8''` in the content disposition so check for this string to get the filename
+            var contentDispositionPrefix = "filename*=UTF-8''";
+            var filenameIndex = contentDisposition.indexOf(contentDispositionPrefix) + contentDispositionPrefix.length;
+
+            // check if filename in content disposition is different from filename being uploaded
+            // if it is, instead set a different flag and don't mark it as done 
+            if (contentDisposition.substring(filenameIndex, contentDisposition.length) != self.file.name.replace(FILENAME_REGEXP, '_')) {
+                self.updateDispositionOnly = true;
+                deferred.resolve(self.url);
+                return;
+            }
+
             self.isPaused = false;
             self.completed = true;
             self.jobDone = true;
@@ -496,7 +511,7 @@ var ERMrest = (function(module) {
                     "content-length": self.file.size,
                     "content-type": self.file.type,
                     "content-md5": self.hash.md5_base64,
-                    "content-disposition": "filename*=UTF-8''" + self.file.name.replace(/[^a-zA-Z0-9_.-]/ig, '_')
+                    "content-disposition": "filename*=UTF-8''" + self.file.name.replace(FILENAME_REGEXP, '_')
                 };
 
                 if (!contextHeaderParams || !_isObject(contextHeaderParams)) {
@@ -528,6 +543,52 @@ var ERMrest = (function(module) {
         return deferred.promise;
     };
 
+    upload.prototype.createUpdateMetadataJob = function (contextHeaderParams) {
+        var self = this;
+        this.erred = false;
+
+        var deferred = module._q.defer();
+
+        if (this.completed && this.jobDone) {
+            deferred.resolve(this.chunkUrl);
+            return deferred.promise;
+        }
+
+        // Prepend the url with server uri if it is relative
+        var url =  self._getAbsoluteUrl(self.url + ";metadata/content-disposition");
+
+        var data = "filename*=UTF-8''" + self.file.name.replace(FILENAME_REGEXP, '_');
+
+        if (!contextHeaderParams || !_isObject(contextHeaderParams)) {
+            contextHeaderParams = {
+                action: "upload/metadata/update",
+                referrer: self.reference.defaultLogInfo
+            };
+            contextHeaderParams.referrer.column = self.column.name;
+        }
+
+        var config = {
+            headers: _generateContextHeader(contextHeaderParams)
+        };
+        config.headers['content-type'] = 'text/plain';
+
+        self.http.put(url, data, config).then(function (response) {
+            if (response) {
+                // mark as completed and job done since this is a metadata update request that doesn't transfer file data
+                self.isPaused = false;
+                self.completed = true;
+                self.jobDone = true;
+
+                deferred.resolve();
+            }
+        }, function(response) {
+            var error = module.responseToError(response);
+            deferred.reject(error);
+        });
+
+        return deferred.promise;
+    }
+
 
     /**
      * @desc Call this function to start chunked upload to server. It reads the file and divides in into chunks
diff --git a/test/specs/upload/tests/02.upload_obj.js b/test/specs/upload/tests/02.upload_obj.js
index 30b15471..110ec136 100644
--- a/test/specs/upload/tests/02.upload_obj.js
+++ b/test/specs/upload/tests/02.upload_obj.js
@@ -1,15 +1,16 @@
 exports.execute = function (options) {
     var exec = require('child_process').execSync;
 
-	var  FileAPI = require('file-api'), File = FileAPI.File;
-	File.prototype.jsdom = true;
+    var FileAPI = require('file-api'), File = FileAPI.File;
+    File.prototype.jsdom = true;
 
     describe("For verifying the upload object, ", function () {
         var schemaName = "upload",
             tableName = "file",
             columnName = "uri",
             chunkSize = 128000,
-            reference, column, filePath, uploadObj, chunkUrl;
+            reference, column, filePath, uploadObj, chunkUrl,
+            filePathDiffName, uploadObjDiffName;
 
         var serverUri = options.url.replace("/ermrest", "");
         var baseUri = options.url + "/catalog/" + process.env.DEFAULT_CATALOG + "/entity/"
@@ -24,6 +25,16 @@ exports.execute = function (options) {
             hash_64: "SxeHAOXzsVznmfLGwUZXQQ=="
         };
 
+        // should be same file as 
+        var fileDiffName = {
+            name: "diff_testfile500kb.png",
+            size: 512000,
+            displaySize: "500KB",
+            type: "image/png",
+            hash: "4b178700e5f3b15ce799f2c6c1465741",
+            hash_64: "SxeHAOXzsVznmfLGwUZXQQ=="
+        };
+
         var firstTime = Date.now();
         var validRow = {
             timestamp: firstTime,
@@ -34,15 +45,18 @@ exports.execute = function (options) {
 
         beforeAll(function (done) {
             filePath = "test/specs/upload/files/" + file.name;
+            filePathDiffName = "test/specs/upload/files/" + fileDiffName.name;
 
             exec("perl -e 'print \"\1\" x " + file.size + "' > " + filePath);
+            exec("cp " + filePath + " " + filePathDiffName);
 
             file.file = new File(filePath);
+            fileDiffName.file = new File(filePathDiffName);
 
             options.ermRest.resolve(baseUri, { cid: "test" }).then(function (response) {
                 reference = response;
 
-                column = reference.columns.find(function(c) { return c.name == columnName; });
+                column = reference.columns.find(function (c) { return c.name == columnName; });
 
                 if (!column) {
                     console.log("Unable to find column " + columnName);
@@ -91,7 +105,7 @@ exports.execute = function (options) {
         it("should verify the URL functions.", function (done) {
             expect(uploadObj.validateURL(validRow)).toBe(true);
 
-            uploadObj.calculateChecksum(validRow).then(function(url) {
+            uploadObj.calculateChecksum(validRow).then(function (url) {
                 expect(url).toBe(serverFilePath, "File generated url is incorrect after calculating the checksum");
 
                 expect(validRow.filename).toBe(file.name, "Valid row name is incorrect");
@@ -110,40 +124,40 @@ exports.execute = function (options) {
                 expect(uploadObj._getAbsoluteUrl(uploadObj.url)).toBe(serverUri + serverFilePath, "absolute url is incorrect");
 
                 done();
-            }, function(err) {
+            }, function (err) {
                 console.dir(err);
                 done.fail();
             });
         });
 
         it("should verify the job doesn't exist yet and neither does the file.", function (done) {
-            uploadObj._getExistingJobStatus().then(function(response) {
+            uploadObj._getExistingJobStatus().then(function (response) {
                 expect(response).not.toBeDefined("Job status is defined");
 
                 return uploadObj.fileExists();
-            }).then(function(response) {
+            }).then(function (response) {
                 expect(response).toBe(serverFilePath, "Server file path is incorrect");
 
                 done();
-            }).catch(function(err) {
+            }).catch(function (err) {
                 console.dir(err);
                 done.fail();
             });
         });
 
         it("should verify the upload job is created.", function (done) {
-            uploadObj.createUploadJob().then(function(response) {
+            uploadObj.createUploadJob().then(function (response) {
                 chunkUrl = response;
                 expect(response.startsWith(serverFilePath)).toBeTruthy("Upload job file path is incorrect");
                 done();
-            }, function(err) {
+            }, function (err) {
                 console.dir(err);
                 done.fail();
             });
         });
 
         it("should verify the job now exists but the file does not yet.", function (done) {
-            uploadObj._getExistingJobStatus().then(function(response) {
+            uploadObj._getExistingJobStatus().then(function (response) {
                 var data = response.data;
 
                 expect(response).toBeDefined("Job status is not defined");
@@ -155,11 +169,11 @@ exports.execute = function (options) {
                 expect(data["chunk-length"]).toBe(chunkSize, "Job status chunk size is incorrect");
 
                 return uploadObj.fileExists();
-            }).then(function(response) {
+            }).then(function (response) {
                 expect(response).toBe(serverFilePath, "Server file path is incorrect");
 
                 done();
-            }).catch(function(err) {
+            }).catch(function (err) {
                 console.dir(err);
                 done.fail();
             });
@@ -169,24 +183,24 @@ exports.execute = function (options) {
             // keeps track of each time notify is called, should be once per chunk
             var counter = 1;
 
-            uploadObj.start().then(function(response) {
+            uploadObj.start().then(function (response) {
                 expect(response).toBe(serverFilePath, "Upload job file path is incorrect");
                 expect(uploadObj.isPaused).toBeFalsy("Upload job is paused");
 
                 done();
-            }, function(err) {
+            }, function (err) {
                 console.dir(err);
                 done.fail();
             }, function notify() {
                 var chunks = uploadObj.chunks;
                 // we get notified by updateProgressBar() after the chunk is PUT to the hatrac server
-                expect(chunks.length).toBe(file.size/chunkSize, "Upload job chunks is incorrect");
+                expect(chunks.length).toBe(file.size / chunkSize, "Upload job chunks is incorrect");
 
                 // verify completed chunks
                 var numCompleteChunks = 0;
                 var numIncompleteChunks = 0
                 // the chunks get added in a random order in the array. sometimes chunk[2] is uploaded before chunk[1]
-                for(var i=0; i<chunks.length; i++) {
+                for (var i = 0; i < chunks.length; i++) {
                     if (chunks[i].completed) {
                         expect(chunks[i].progress).toBe(chunkSize, "Chunk progress is not the same as chunk size after completion");
                         numCompleteChunks++;
@@ -196,45 +210,168 @@ exports.execute = function (options) {
                     }
                 }
                 expect(numCompleteChunks).toBe(counter, "Not enough chunks completed");
-                expect(numIncompleteChunks).toBe(chunks.length-counter, "Too many chunks completed");
+                expect(numIncompleteChunks).toBe(chunks.length - counter, "Too many chunks completed");
 
                 // verify the file is uploaded or not
-                if(counter == chunks.length) {
+                if (counter == chunks.length) {
                     expect(uploadObj.completed).toBeTruthy("File not yet created");
                 } else {
                     expect(uploadObj.completed).toBeFalsy("File has been created");
                 }
                 counter++;
-            }).catch(function(err) {
+            }).catch(function (err) {
                 console.dir(err);
                 done.fail();
             });
         });
 
         it("should complete the upload.", function (done) {
-            uploadObj.completeUpload().then(function(response) {
+            uploadObj.completeUpload().then(function (response) {
                 expect(response.startsWith(serverFilePath + ":")).toBeTruthy("Upload job file path is incorrect");
                 expect(uploadObj.jobDone).toBeTruthy("Upload job is not complete");
 
                 done();
-            }, function(err) {
+            }, function (err) {
                 console.dir(err);
                 done.fail();
             });
         });
 
+        // test trying to upload the same file but with a different file.name
+        describe("now trying to upload the same file again with a different file name", function () {
+            it("should have properties set appropriately by its constructor.", function () {
+                uploadObjDiffName = new options.ermRest.Upload(fileDiffName.file, {
+                    column: column,
+                    reference: reference,
+                    chunkSize: chunkSize
+                });
+
+                expect(uploadObjDiffName.PART_SIZE).toBe(chunkSize, "chunk size is incorrect");
+                expect(uploadObjDiffName.CHUNK_QUEUE_SIZE).toBe(4, "chunk queue size is incorrect");
+                expect(uploadObjDiffName.file).toEqual(fileDiffName.file, "file is not an Object");
+                expect(uploadObjDiffName.column).toEqual(column, "column is incorrect");
+
+                // reference associated
+                expect(uploadObjDiffName.reference).toEqual(reference, "reference is incorrect");
+                expect(uploadObjDiffName.SERVER_URI).toBe(serverUri, "server uri is incorrect");
+                expect(uploadObjDiffName.http).toEqual(reference._server.http, "http is incorrect");
+
+                // initial values
+                expect(uploadObjDiffName.isPaused).toBeFalsy("is paused is incorrect");
+                expect(uploadObjDiffName.uploadedSize).toBe(0, "upload size is incorrect");
+                expect(uploadObjDiffName.chunks).toBeDefined("chunks is incorrect");
+                expect(uploadObjDiffName.log).toEqual(console.log, "log is incorrect");
+            });
+
+            it("should have a file the same as the one that was uploaded.", function () {
+                expect(uploadObjDiffName.file.path).toBe(filePathDiffName, "file path is incorrect");
+                expect(uploadObjDiffName.file.name).toBe(fileDiffName.name, "file name is incorrect");
+                expect(uploadObjDiffName.file.type).toBe(fileDiffName.type, "file type is incorrect");
+                expect(uploadObjDiffName.file.size).toBe(fileDiffName.size, "file size is incorrect");
+            });
+
+            it("should verify the URL functions.", function (done) {
+                expect(uploadObjDiffName.validateURL(validRow)).toBe(true);
+
+                uploadObjDiffName.calculateChecksum(validRow).then(function (url) {
+                    expect(url).toBe(serverFilePath, "File generated url is incorrect after calculating the checksum");
+
+                    expect(validRow.filename).toBe(fileDiffName.name, "Valid row name is incorrect");
+                    expect(validRow.bytes).toBe(fileDiffName.size, "Valid row size is incorrect");
+                    expect(validRow.checksum).toBe(fileDiffName.hash, "Valid row hash is incorrect");
+
+                    expect(uploadObjDiffName.hash instanceof options.ermRest.Checksum).toBeTruthy("hash is not of type ermRest.Checksum")
+
+                    // calculateChecksum() calls generateUrl(), verify values are set properly on uploadObj
+                    expect(uploadObjDiffName.url).toBe(serverFilePath, "url is incorrect");
+                    expect(uploadObjDiffName.chunkUrl).toBeFalsy("chunk url is incorrect");
+                    expect(uploadObjDiffName.fileExistsFlag).toBeFalsy("file exists flag is incorrect");
+                    expect(uploadObjDiffName.completed).toBeFalsy("completed is incorrect");
+                    expect(uploadObjDiffName.jobDone).toBeFalsy("job done is incorrect");
+
+                    expect(uploadObjDiffName._getAbsoluteUrl(uploadObjDiffName.url)).toBe(serverUri + serverFilePath, "absolute url is incorrect");
+
+                    done();
+                }, function (err) {
+                    console.dir(err);
+                    done.fail();
+                });
+            });
+
+            it("should verify the job doesn't exist yet but a version of the same file does with a different filename.", function (done) {
+                uploadObjDiffName._getExistingJobStatus().then(function (response) {
+                    expect(response).not.toBeDefined("Job status is defined");
+
+                    return uploadObjDiffName.fileExists();
+                }).then(function (response) {
+                    expect(response).toBe(serverFilePath, "Server file path is incorrect");
+
+                    expect(uploadObjDiffName.updateDispositionOnly).toBeTruthy('update disposition only flag is incorrect');
+
+                    done();
+                }).catch(function (err) {
+                    console.dir(err);
+                    done.fail();
+                });
+            });
+
+            it("should verify the update metadata job is created and succeeds.", function (done) {
+                uploadObjDiffName.createUpdateMetadataJob().then(function () {
+                    expect(uploadObjDiffName.isPaused).toBeFalsy("is paused is incorrect");
+                    expect(uploadObjDiffName.completed).toBeTruthy("completed is incorrect");
+                    expect(uploadObjDiffName.jobDone).toBeTruthy("job done is incorrect");
+
+                    done();
+                }, function (err) {
+                    console.dir(err);
+                    done.fail();
+                });
+            });
+
+            it("should return since file didn't need to be uploaded and is marked complete already.", function (done) {
+                // keeps track of each time notify is called, should be once per chunk
+                var counter = 1;
+
+                uploadObjDiffName.start().then(function (response) {
+                    expect(response).toBe(serverFilePath, "Upload job file path is incorrect");
+                    expect(uploadObjDiffName.isPaused).toBeFalsy("is paused is incorrect");
+
+                    done();
+                }).catch(function (err) {
+                    console.dir(err);
+                    done.fail();
+                });
+            });
+
+            it("should complete the upload.", function (done) {
+                uploadObjDiffName.completeUpload().then(function (response) {
+                    // no ':' appended since it's not a versioned url for the response
+                    expect(response.startsWith(serverFilePath)).toBeTruthy("Upload job file path is incorrect");
+                    expect(uploadObjDiffName.jobDone).toBeTruthy("Upload job is not complete");
+
+                    done();
+                }, function (err) {
+                    console.dir(err);
+                    done.fail();
+                });
+            });
+        });
+
         // TODO: Upload.pause(), Upload.resume(), and Upload.cancel() are not tested.
         // we can't interrupt a promise even during the notify callback. We will have to look into
         // a way to mock the upload endpoint and change the Synchronization so it is ignored
 
-        afterAll(function(done) {
+        afterAll(function (done) {
             // removes the file from the chaise folder
             exec('rm ' + filePath);
+            exec('rm ' + filePathDiffName);
             // removes the files from hatrac
-            uploadObj.deleteFile().then(function() {
+            uploadObj.deleteFile().then(function () {
+                return uploadObjDiffName.deleteFile();
+            }).then(function () {
 
                 done();
-            }).catch(function(err) {
+            }).catch(function (err) {
                 console.dir(err);
                 done.fail();
             });