Merge pull request #57

src/Exception/GridFSCorruptFileException.php

+<?php
+
+namespace MongoDB\Exception;
+
+class GridFSCorruptFileException extends \MongoDB\Driver\Exception\RuntimeException implements Exception
+{
+}

src/Exception/GridFSFileNotFoundException.php

+<?php
+
+namespace MongoDB\Exception;
+
+class GridFSFileNotFoundException extends \MongoDB\Driver\Exception\RuntimeException implements Exception
+{
+    public function __construct($filename, $namespace)
+    {
+        parent::__construct(sprintf('Unable to find file "%s" in namespace "%s"', $filename, $namespace));
+    }
+}

src/GridFS/GridFSCollectionsWrapper.php

+<?php
+
+namespace MongoDB\GridFS;
+
+use MongoDB\Collection;
+use MongoDB\Driver\Manager;
+use MongoDB\Driver\ReadPreference;
+use MongoDB\Driver\WriteConcern;
+use MongoDB\Exception\InvalidArgumentTypeException;
+
+/**
+ * GridFSCollectionsWrapper abstracts the GridFS files and chunks collections.
+ *
+ * @internal
+ */
+class GridFSCollectionsWrapper
+{
+    private $chunksCollection;
+    private $ensuredIndexes = false;
+    private $filesCollection;
+
+    /**
+     * Constructs a GridFS collection wrapper.
+     *
+     * @see Collection::__construct() for supported options
+     * @param Manager $manager           Manager instance from the driver
+     * @param string  $databaseName      Database name
+     * @param string  $bucketName        Bucket name
+     * @param array   $collectionOptions Collection options
+     * @throws InvalidArgumentException
+     */
+    public function __construct(Manager $manager, $databaseName, $bucketName, array $collectionOptions = [])
+    {
+        $this->filesCollection = new Collection($manager, sprintf('%s.%s.files', $databaseName, $bucketName), $collectionOptions);
+        $this->chunksCollection = new Collection($manager, sprintf('%s.%s.chunks', $databaseName, $bucketName), $collectionOptions);
+    }
+
+    public function dropCollections(){
+        $this->filesCollection-> drop();
+        $this->chunksCollection->drop();
+    }
+
+    public function getChunksCollection()
+    {
+        return $this->chunksCollection;
+    }
+
+    public function getFilesCollection()
+    {
+        return $this->filesCollection;
+    }
+
+    public function insertChunk($chunk)
+    {
+        $this->ensureIndexes();
+        $this->chunksCollection->insertOne($chunk);
+    }
+
+    public function insertFile($file)
+    {
+        $this->ensureIndexes();
+        $this->filesCollection->insertOne($file);
+    }
+
+    private function ensureChunksIndex()
+    {
+        foreach ($this->chunksCollection->listIndexes() as $index) {
+            if ($index->isUnique() && $index->getKey() === ['files_id' => 1, 'n' => 1]) {
+                return;
+            }
+        }
+
+        $this->chunksCollection->createIndex(['files_id' => 1, 'n' => 1], ['unique' => true]);
+    }
+
+    private function ensureFilesIndex()
+    {
+        foreach ($this->filesCollection->listIndexes() as $index) {
+            if ($index->getKey() === ['filename' => 1, 'uploadDate' => 1]) {
+                return;
+            }
+        }
+
+        $this->filesCollection->createIndex(['filename' => 1, 'uploadDate' => 1]);
+    }
+
+    private function ensureIndexes()
+    {
+        if ($this->ensuredIndexes) {
+            return;
+        }
+
+        if ( ! $this->isFilesCollectionEmpty()) {
+            return;
+        }
+
+        $this->ensureFilesIndex();
+        $this->ensureChunksIndex();
+        $this->ensuredIndexes = true;
+    }
+
+    private function isFilesCollectionEmpty()
+    {
+        return null === $this->filesCollection->findOne([], [
+            'readPreference' => new ReadPreference(ReadPreference::RP_PRIMARY),
+            'projection' => ['_id' => 1],
+        ]);
+    }
+}

src/GridFS/GridFSDownload.php

+<?php
+
+namespace MongoDB\GridFS;
+
+use MongoDB\Driver\Exception\Exception;
+use MongoDB\Exception\GridFSCorruptFileException;
+use stdClass;
+
+/**
+ * GridFSDownload abstracts the process of reading a GridFS file.
+ *
+ * @internal
+ */
+class GridFSDownload
+{
+    private $buffer;
+    private $bufferEmpty = true;
+    private $bufferFresh = true;
+    private $bytesSeen = 0;
+    private $chunkOffset = 0;
+    private $chunksIterator;
+    private $collectionsWrapper;
+    private $file;
+    private $firstCheck = true;
+    private $iteratorEmpty = false;
+    private $numChunks;
+
+    /**
+     * Constructs a GridFS download stream.
+     *
+     * @param GridFSCollectionsWrapper $collectionsWrapper GridFS collections wrapper
+     * @param stdClass                 $file               GridFS file document
+     * @throws GridFSCorruptFileException
+     */
+    public function __construct(GridFSCollectionsWrapper $collectionsWrapper, stdClass $file)
+    {
+        $this->collectionsWrapper = $collectionsWrapper;
+        $this->file = $file;
+
+        try {
+            $cursor = $this->collectionsWrapper->getChunksCollection()->find(
+                ['files_id' => $this->file->_id],
+                ['sort' => ['n' => 1]]
+            );
+        } catch (Exception $e) {
+            // TODO: Why do we replace a driver exception with GridFSCorruptFileException here?
+            throw new GridFSCorruptFileException();
+        }
+
+        $this->chunksIterator = new \IteratorIterator($cursor);
+        $this->numChunks = ($file->length >= 0) ? ceil($file->length / $file->chunkSize) : 0;
+        $this->buffer = fopen('php://temp', 'w+');
+    }
+
+    public function close()
+    {
+        fclose($this->buffer);
+    }
+
+    public function downloadNumBytes($numToRead)
+    {
+        $output = "";
+
+        if ($this->bufferFresh) {
+            rewind($this->buffer);
+            $this->bufferFresh = false;
+        }
+
+        // TODO: Should we be checking for fread errors here?
+        $output = fread($this->buffer, $numToRead);
+
+        if (strlen($output) == $numToRead) {
+            return $output;
+        }
+
+        fclose($this->buffer);
+        $this->buffer = fopen("php://temp", "w+");
+
+        $this->bufferFresh = true;
+        $this->bufferEmpty = true;
+
+        $bytesLeft = $numToRead - strlen($output);
+
+        while (strlen($output) < $numToRead && $this->advanceChunks()) {
+            $bytesLeft = $numToRead - strlen($output);
+            $output .= substr($this->chunksIterator->current()->data->getData(), 0, $bytesLeft);
+        }
+
+        if ( ! $this->iteratorEmpty && $this->file->length > 0 && $bytesLeft < strlen($this->chunksIterator->current()->data->getData())) {
+            fwrite($this->buffer, substr($this->chunksIterator->current()->data->getData(), $bytesLeft));
+            $this->bufferEmpty = false;
+        }
+
+        return $output;
+    }
+
+    public function downloadToStream($destination)
+    {
+        while ($this->advanceChunks()) {
+            // TODO: Should we be checking for fwrite errors here?
+            fwrite($destination, $this->chunksIterator->current()->data->getData());
+        }
+    }
+
+    public function getFile()
+    {
+        return $this->file;
+    }
+
+    public function getId()
+    {
+        return $this->file->_id;
+    }
+
+    public function getSize()
+    {
+        return $this->file->length;
+    }
+
+    public function isEOF()
+    {
+        return ($this->iteratorEmpty && $this->bufferEmpty);
+    }
+
+    private function advanceChunks()
+    {
+        if ($this->chunkOffset >= $this->numChunks) {
+            $this->iteratorEmpty = true;
+
+            return false;
+        }
+
+        if ($this->firstCheck) {
+            $this->chunksIterator->rewind();
+            $this->firstCheck = false;
+        } else {
+            $this->chunksIterator->next();
+        }
+
+        if ( ! $this->chunksIterator->valid()) {
+            throw new GridFSCorruptFileException();
+        }
+
+        if ($this->chunksIterator->current()->n != $this->chunkOffset) {
+            throw new GridFSCorruptFileException();
+        }
+
+        $actualChunkSize = strlen($this->chunksIterator->current()->data->getData());
+
+        $expectedChunkSize = ($this->chunkOffset == $this->numChunks - 1)
+            ? ($this->file->length - $this->bytesSeen)
+            : $this->file->chunkSize;
+
+        if ($actualChunkSize != $expectedChunkSize) {
+            throw new GridFSCorruptFileException();
+        }
+
+        $this->bytesSeen += $actualChunkSize;
+        $this->chunkOffset++;
+
+        return true;
+    }
+}

src/GridFS/GridFSUpload.php

+<?php
+
+namespace MongoDB\GridFS;
+
+use MongoDB\BSON\Binary;
+use MongoDB\BSON\ObjectId;
+use MongoDB\BSON\UTCDateTime;
+use MongoDB\Driver\Exception\Exception;
+use MongoDB\Exception\InvalidArgumentTypeException;
+
+/**
+ * GridFSUpload abstracts the process of writing a GridFS file.
+ *
+ * @internal
+ */
+class GridFSUpload
+{
+    private $buffer;
+    private $bufferLength = 0;
+    private $chunkOffset = 0;
+    private $chunkSize;
+    private $collectionsWrapper;
+    private $ctx;
+    private $file;
+    private $indexChecker;
+    private $isClosed = false;
+    private $length = 0;
+
+    /**
+     * Constructs a GridFS upload stream.
+     *
+     * Supported options:
+     *
+     *  * aliases (array of strings): DEPRECATED An array of aliases. 
+     *    Applications wishing to store aliases should add an aliases field to
+     *    the metadata document instead.
+     *
+     *  * chunkSizeBytes (integer): The chunk size in bytes. Defaults to
+     *    261120 (i.e. 255 KiB).
+     *
+     *  * contentType (string): DEPRECATED content type to be stored with the
+     *    file. This information should now be added to the metadata.
+     *
+     *  * metadata (document): User data for the "metadata" field of the files
+     *    collection document.
+     *
+     * @param GridFSCollectionsWrapper $collectionsWrapper GridFS collections wrapper
+     * @param string                   $filename           File name
+     * @param array                    $options            Upload options
+     * @throws InvalidArgumentTypeException
+     */
+    public function __construct(GridFSCollectionsWrapper $collectionsWrapper, $filename, array $options = [])
+    {
+        $options += ['chunkSizeBytes' => 261120];
+
+        if (isset($options['aliases']) && ! \MongoDB\is_string_array($options['aliases'])) {
+            throw new InvalidArgumentTypeException('"aliases" option', $options['aliases'], 'array of strings');
+        }
+
+        if (isset($options['contentType']) && ! is_string($options['contentType'])) {
+            throw new InvalidArgumentTypeException('"contentType" option', $options['contentType'], 'string');
+        }
+
+        if (isset($options['metadata']) && ! is_array($options['metadata']) && ! is_object($options['metadata'])) {
+            throw new InvalidArgumentTypeException('"metadata" option', $options['metadata'], 'array or object');
+        }
+
+        $this->chunkSize = $options['chunkSizeBytes'];
+        $this->collectionsWrapper = $collectionsWrapper;
+        $this->buffer = fopen('php://temp', 'w+');
+        $this->ctx = hash_init('md5');
+
+        $this->file = [
+            '_id' => new ObjectId(),
+            'chunkSize' => $this->chunkSize,
+            'filename' => (string) $filename,
+            'uploadDate' => $this->createUploadDate(),
+        ] + array_intersect_key($options, ['aliases' => 1, 'contentType' => 1, 'metadata' => 1]);
+    }
+
+    /**
+     * Closes an active stream and flushes all buffered data to GridFS.
+     */
+    public function close()
+    {
+        if ($this->isClosed) {
+            // TODO: Should this be an error condition? e.g. BadMethodCallException
+            return;
+        }
+
+        rewind($this->buffer);
+        $cached = stream_get_contents($this->buffer);
+
+        if (strlen($cached) > 0) {
+            $this->insertChunk($cached);
+        }
+
+        fclose($this->buffer);
+        $this->fileCollectionInsert();
+        $this->isClosed = true;
+    }
+
+    public function getChunkSize()
+    {
+        return $this->chunkSize;
+    }
+
+    public function getFile()
+    {
+        return $this->file;
+    }
+
+    public function getId()
+    {
+        return $this->file['_id'];
+    }
+
+    public function getLength()
+    {
+        return $this->length;
+    }
+
+    public function getSize()
+    {
+        return $this->length;
+    }
+
+    /**
+     * Inserts binary data into GridFS via chunks.
+     *
+     * Data will be buffered internally until chunkSizeBytes are accumulated, at
+     * which point a chunk's worth of data will be inserted and the buffer
+     * reset.
+     *
+     * @param string $toWrite Binary data to write
+     * @return int
+     */
+    public function insertChunks($toWrite)
+    {
+        if ($this->isClosed) {
+            // TODO: Should this be an error condition? e.g. BadMethodCallException
+            return;
+        }
+
+        $readBytes = 0;
+
+        while ($readBytes != strlen($toWrite)) {
+            $addToBuffer = substr($toWrite, $readBytes, $this->chunkSize - $this->bufferLength);
+            fwrite($this->buffer, $addToBuffer);
+            $readBytes += strlen($addToBuffer);
+            $this->bufferLength += strlen($addToBuffer);
+
+            if ($this->bufferLength == $this->chunkSize) {
+                rewind($this->buffer);
+                $this->insertChunk(stream_get_contents($this->buffer));
+                ftruncate($this->buffer, 0);
+                $this->bufferLength = 0;
+            }
+        }
+
+        return $readBytes;
+    }
+
+    public function isEOF()
+    {
+        return $this->isClosed;
+    }
+
+    /**
+     * Writes the contents of a readable stream to a GridFS file.
+     *
+     * @param resource $source Readable stream
+     * @return ObjectId
+     */
+    public function uploadFromStream($source)
+    {
+        if ( ! is_resource($source) || get_resource_type($source) != "stream") {
+            throw new InvalidArgumentTypeException('$stream', $source, 'resource');
+        }
+
+        $streamMetadata = stream_get_meta_data($source);
+
+        while ($data = $this->readChunk($source)) {
+            $this->insertChunk($data);
+        }
+
+        return $this->fileCollectionInsert();
+    }
+
+    private function abort()
+    {
+        $this->collectionsWrapper->getChunksCollection()->deleteMany(['files_id' => $this->file['_id']]);
+        $this->collectionsWrapper->getFilesCollection()->deleteOne(['_id' => $this->file['_id']]);
+        $this->isClosed = true;
+    }
+
+    // From: http://stackoverflow.com/questions/3656713/how-to-get-current-time-in-milliseconds-in-php
+    private function createUploadDate()
+    {
+        $parts = explode(' ', microtime());
+        $milliseconds = sprintf('%d%03d', $parts[1], $parts[0] * 1000);
+
+        return new UTCDateTime($milliseconds);
+    }
+
+    private function fileCollectionInsert()
+    {
+        if ($this->isClosed) {
+            // TODO: Should this be an error condition? e.g. BadMethodCallException
+            return;
+        }
+
+        $md5 = hash_final($this->ctx);
+
+        $this->file['length'] = $this->length;
+        $this->file['md5'] = $md5;
+
+        $this->collectionsWrapper->insertFile($this->file);
+
+        return $this->file['_id'];
+    }
+
+    private function insertChunk($data)
+    {
+        if ($this->isClosed) {
+            // TODO: Should this be an error condition? e.g. BadMethodCallException
+            return;
+        }
+
+        $toUpload = [
+            'files_id' => $this->file['_id'],
+            'n' => $this->chunkOffset,
+            'data' => new Binary($data, Binary::TYPE_GENERIC),
+        ];
+
+        hash_update($this->ctx, $data);
+
+        $this->collectionsWrapper->insertChunk($toUpload);
+        $this->length += strlen($data);
+        $this->chunkOffset++;
+    }
+
+    private function readChunk($source)
+    {
+        try {
+            $data = fread($source, $this->chunkSize);
+        } catch (Exception $e) {
+            $this->abort();
+            throw $e;
+        }
+
+        return $data;
+    }
+}

src/GridFS/StreamWrapper.php

+<?php
+
+namespace MongoDB\GridFS;
+
+/**
+ * Stream wrapper for reading and writing a GridFS file.
+ *
+ * @internal
+ * @see Bucket::openUploadStream()
+ * @see Bucket::openDownloadStream()
+ */
+class StreamWrapper
+{
+    public $context;
+
+    private $collectionsWrapper;
+    private $gridFSStream;
+    private $id;
+    private $mode;
+
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    public function openReadStream()
+    {
+        $context = stream_context_get_options($this->context);
+        $this->gridFSStream = new GridFSDownload($this->collectionsWrapper, $context['gridfs']['file']);
+        $this->id = $this->gridFSStream->getId();
+
+        return true;
+    }
+
+    public function openWriteStream()
+    {
+        $context = stream_context_get_options($this->context);
+        $options = $context['gridfs']['uploadOptions'];
+        $this->gridFSStream = new GridFSUpload($this->collectionsWrapper, $this->identifier, $options);
+        $this->id = $this->gridFSStream->getId();
+
+        return true;
+    }
+
+    /**
+     * Register the GridFS stream wrapper.
+     */
+    public static function register()
+    {
+        if (in_array('gridfs', stream_get_wrappers())) {
+            stream_wrapper_unregister('gridfs');
+        }
+
+        stream_wrapper_register('gridfs', get_called_class(), \STREAM_IS_URL);
+    }
+
+    public function stream_close()
+    {
+        $this->gridFSStream->close();
+    }
+
+    public function stream_eof()
+    {
+        return $this->gridFSStream->isEOF();
+    }
+
+    public function stream_open($path, $mode, $options, &$openedPath)
+    {
+        $this->initProtocol($path);
+        $context = stream_context_get_options($this->context);
+        $this->collectionsWrapper = $context['gridfs']['collectionsWrapper'];
+        $this->mode = $mode;
+
+        switch ($this->mode) {
+            case 'r': return $this->openReadStream();
+            case 'w': return $this->openWriteStream();
+            default:  return false;
+        }
+    }
+
+    public function stream_read($count)
+    {
+        return $this->gridFSStream->downloadNumBytes($count);
+    }
+
+    public function stream_stat()
+    {
+        $stat = $this->getStatTemplate();
+        $stat[7] = $stat['size'] = $this->gridFSStream->getSize();
+
+        return $stat;
+    }
+
+    public function stream_write($data)
+    {
+        $this->gridFSStream->insertChunks($data);
+
+        return strlen($data);
+    }
+
+    /**
+     * Gets a URL stat template with default values
+     * from https://github.com/aws/aws-sdk-php/blob/master/src/S3/StreamWrapper.php
+     * @return array
+     */
+    private function getStatTemplate()
+    {
+        return [
+            0  => 0,  'dev'     => 0,
+            1  => 0,  'ino'     => 0,
+            2  => 0,  'mode'    => 0,
+            3  => 0,  'nlink'   => 0,
+            4  => 0,  'uid'     => 0,
+            5  => 0,  'gid'     => 0,
+            6  => -1, 'rdev'    => -1,
+            7  => 0,  'size'    => 0,
+            8  => 0,  'atime'   => 0,
+            9  => 0,  'mtime'   => 0,
+            10 => 0,  'ctime'   => 0,
+            11 => -1, 'blksize' => -1,
+            12 => -1, 'blocks'  => -1,
+        ];
+    }
+
+    private function initProtocol($path)
+    {
+        $parsed_path = parse_url($path);
+        $this->identifier = substr($parsed_path['path'], 1);
+    }
+}

src/functions.php

@@ -140,3 +140,16 @@ function server_supports_feature(Server $server, $feature)
 
     return ($minWireVersion <= $feature && $maxWireVersion >= $feature);
 }
+
+function is_string_array($input) {
+    if (!is_array($input)){
+        return false;
+    }
+    foreach($input as $item) {
+        if (!is_string($item)) {
+            return false;
+        }
+    }
+    return true;
+}
+

tests/GridFS/FunctionalTestCase.php

+<?php
+
+namespace MongoDB\Tests\GridFS;
+
+use MongoDB\GridFS;
+use MongoDB\Collection;
+use MongoDB\Tests\FunctionalTestCase as BaseFunctionalTestCase;
+
+/**
+ * Base class for GridFS functional tests.
+ */
+abstract class FunctionalTestCase extends BaseFunctionalTestCase
+{
+    protected $bucket;
+    protected $collectionsWrapper;
+
+    public function setUp()
+    {
+        parent::setUp();
+       foreach(['fs.files', 'fs.chunks'] as $collection){
+            $col = new Collection($this->manager, sprintf("%s.%s",$this->getDatabaseName(), $collection));
+            $col->drop();
+        }
+        $this->bucket = new \MongoDB\GridFS\Bucket($this->manager, $this->getDatabaseName());
+        $this->collectionsWrapper = $this->bucket->getCollectionsWrapper();
+    }
+
+    public function tearDown()
+    {
+       foreach(['fs.files', 'fs.chunks'] as $collection){
+            $col = new Collection($this->manager, sprintf("%s.%s",$this->getDatabaseName(), $collection));
+            $col->drop();
+        }
+        if ($this->hasFailed()) {
+            return;
+        }
+    }
+
+    public function provideInsertChunks()
+    {
+        $dataVals = [];
+        $testArgs[][] = "hello world";
+        $testArgs[][] = "1234567890";
+        $testArgs[][] = "~!@#$%^&*()_+";
+        for($j=0; $j<30; $j++){
+            $randomTest = "";
+            for($i=0; $i<100; $i++){
+                $randomTest .= chr(rand(0, 256));
+            }
+            $testArgs[][] = $randomTest;
+        }
+        $utf8="";
+        for($i=0; $i<256; $i++){
+            $utf8 .= chr($i);
+        }
+        $testArgs[][]=$utf8;
+        return $testArgs;
+    }
+
+}

tests/GridFS/Specification/tests/README.rst

+GridFS Tests
+============
+
+The YAML and JSON files in this directory are platform-independent tests
+meant to exercise a driver's implementation of GridFS.
+
+Converting to JSON
+==================
+
+The tests are written in YAML because it is easier for humans to write
+and read, and because YAML supports a standard comment format. Each test
+is also provided in JSON format because in some languages it is easier
+to parse JSON than YAML.
+
+If you modify any test, you should modify the YAML file and then
+regenerate the JSON file from it. 
+	
+One way to convert the files is using an online web page. I used:
+
+http://www.json2yaml.com/
+
+It's advertised as a JSON to YAML converter but it can be used in either direction.
+
+Note: the yaml2json utility from npm is not capable of converting these YAML tests
+because it doesn't implement the full YAML spec.
+	
+Format
+======
+
+Each test file has two top level sections:
+
+1. data
+2. tests
+
+The data section defines the initial contents of the files and chunks
+collections for all tests in that file.
+
+The tests section defines the tests to be run. The format of the tests
+section will vary slightly depending on what tests are being defined.
+In general, they will have the following sections:
+
+1. description
+2. arrange
+3. act
+4. assert
+
+The arrange section, if present, defines changes to be made to the 
+initial contents of the files and chunks collections (as defined by
+the data section) before this particular test is run. These changes
+are described in the form of write commands that can be sent directly
+to MongoDB.
+
+The act section defines what operation (with which arguments) should
+be performed.
+
+The assert section defines what should be true at the end of the test.
+This includes checking the return value of the operation, as well as
+checking the expected contents of the files and chunks collections. The
+expected contents of the files and chunks collections are described
+in the form of write commands that modify collections named
+expected.files and expected.chunks. Before running these commands,
+load the initial files and chunks documents into the expected.files
+and expected.chunks collections and then run the commands. At that point
+you can assert that fs.files and expected.files are the same, and that
+expected.chunks and fs.chunks are the same. 
+
+For operations that are expected to succeed the assert section contains
+a "result" element describing the expected result. For operations
+that are expected to fail the assert section contains an "error"
+element describing the expected failure.
+
+The "result" element is either the expected result when it is possible to 
+know the result in advance, or it is the special value "&result"
+which means that we expect a result (not a failure) but the actual
+value of the result could be anything. The notation "&result" is
+modeled after YAML syntax for defining an anchor, and the 
+result value may be referenced later in the assert section as
+"*result".
+
+Another special notation in the assert section is "*actual", which
+is used when the value of a field cannot be known in advance of the
+test, so the assert logic should accept whatever the actual value
+ended up being.

tests/GridFS/Specification/tests/delete.json

+{
+  "data": {
+    "files": [
+      {
+        "_id": {
+          "$oid": "000000000000000000000001"
+        },
+        "length": 0,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-01T00:00:00.000Z"
+        },
+        "md5": "d41d8cd98f00b204e9800998ecf8427e",
+        "filename": "length-0",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000002"
+        },
+        "length": 0,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-01T00:00:00.000Z"
+        },
+        "md5": "d41d8cd98f00b204e9800998ecf8427e",
+        "filename": "length-0-with-empty-chunk",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000003"
+        },
+        "length": 2,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-01T00:00:00.000Z"
+        },
+        "md5": "c700ed4fdb1d27055aa3faa2c2432283",
+        "filename": "length-2",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000004"
+        },
+        "length": 8,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-01T00:00:00.000Z"
+        },
+        "md5": "dd254cdc958e53abaa67da9f797125f5",
+        "filename": "length-8",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      }
+    ],
+    "chunks": [
+      {
+        "_id": {
+          "$oid": "000000000000000000000001"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000002"
+        },
+        "n": 0,
+        "data": {
+          "$hex": ""
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000002"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000003"
+        },
+        "n": 0,
+        "data": {
+          "$hex": "1122"
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000003"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000004"
+        },
+        "n": 0,
+        "data": {
+          "$hex": "11223344"
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000004"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000004"
+        },
+        "n": 1,
+        "data": {
+          "$hex": "55667788"
+        }
+      }
+    ]
+  },
+  "tests": [
+    {
+      "description": "Delete when length is 0",
+      "act": {
+        "operation": "delete",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000001"
+          }
+        }
+      },
+      "assert": {
+        "result": "void",
+        "data": [
+          {
+            "delete": "expected.files",
+            "deletes": [
+              {
+                "q": {
+                  "_id": {
+                    "$oid": "000000000000000000000001"
+                  }
+                },
+                "limit": 1
+              }
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "description": "Delete when length is 0 and there is one extra empty chunk",
+      "act": {
+        "operation": "delete",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000002"
+          }
+        }
+      },
+      "assert": {
+        "result": "void",
+        "data": [
+          {
+            "delete": "expected.files",
+            "deletes": [
+              {
+                "q": {
+                  "_id": {
+                    "$oid": "000000000000000000000002"
+                  }
+                },
+                "limit": 1
+              }
+            ]
+          },
+          {
+            "delete": "expected.chunks",
+            "deletes": [
+              {
+                "q": {
+                  "files_id": {
+                    "$oid": "000000000000000000000002"
+                  }
+                },
+                "limit": 0
+              }
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "description": "Delete when length is 8",
+      "act": {
+        "operation": "delete",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000004"
+          }
+        }
+      },
+      "assert": {
+        "result": "void",
+        "data": [
+          {
+            "delete": "expected.files",
+            "deletes": [
+              {
+                "q": {
+                  "_id": {
+                    "$oid": "000000000000000000000004"
+                  }
+                },
+                "limit": 1
+              }
+            ]
+          },
+          {
+            "delete": "expected.chunks",
+            "deletes": [
+              {
+                "q": {
+                  "files_id": {
+                    "$oid": "000000000000000000000004"
+                  }
+                },
+                "limit": 0
+              }
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "description": "Delete when files entry does not exist",
+      "act": {
+        "operation": "delete",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000000"
+          }
+        }
+      },
+      "assert": {
+        "error": "FileNotFound"
+      }
+    },
+    {
+      "description": "Delete when files entry does not exist and there are orphaned chunks",
+      "arrange": {
+        "data": [
+          {
+            "delete": "fs.files",
+            "deletes": [
+              {
+                "q": {
+                  "_id": {
+                    "$oid": "000000000000000000000004"
+                  }
+                },
+                "limit": 1
+              }
+            ]
+          }
+        ]
+      },
+      "act": {
+        "operation": "delete",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000004"
+          }
+        }
+      },
+      "assert": {
+        "error": "FileNotFound",
+        "data": [
+          {
+            "delete": "expected.files",
+            "deletes": [
+              {
+                "q": {
+                  "_id": {
+                    "$oid": "000000000000000000000004"
+                  }
+                },
+                "limit": 1
+              }
+            ]
+          },
+          {
+            "delete": "expected.chunks",
+            "deletes": [
+              {
+                "q": {
+                  "files_id": {
+                    "$oid": "000000000000000000000004"
+                  }
+                },
+                "limit": 0
+              }
+            ]
+          }
+        ]
+      }
+    }
+  ]
+}
\ No newline at end of file

tests/GridFS/Specification/tests/delete.yml

+data:
+    files:
+        -
+            _id: { "$oid" : "000000000000000000000001" }
+            length: 0
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-01T00:00:00.000Z" }
+            md5: "d41d8cd98f00b204e9800998ecf8427e"
+            filename: "length-0"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+        -
+            _id: { "$oid" : "000000000000000000000002" }
+            length: 0
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-01T00:00:00.000Z" }
+            md5: "d41d8cd98f00b204e9800998ecf8427e"
+            filename: "length-0-with-empty-chunk"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+        -
+            _id: { "$oid" : "000000000000000000000003" }
+            length: 2
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-01T00:00:00.000Z" }
+            md5: "c700ed4fdb1d27055aa3faa2c2432283"
+            filename: "length-2"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+        -
+            _id: { "$oid" : "000000000000000000000004" }
+            length: 8
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-01T00:00:00.000Z" }
+            md5: "dd254cdc958e53abaa67da9f797125f5"
+            filename: "length-8"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+    chunks:
+        - { _id : { "$oid" : "000000000000000000000001" }, files_id : { "$oid" : "000000000000000000000002" }, n : 0, data : { $hex : "" } }
+        - { _id : { "$oid" : "000000000000000000000002" }, files_id : { "$oid" : "000000000000000000000003" }, n : 0, data : { $hex : "1122" } }
+        - { _id : { "$oid" : "000000000000000000000003" }, files_id : { "$oid" : "000000000000000000000004" }, n : 0, data : { $hex : "11223344" } }
+        - { _id : { "$oid" : "000000000000000000000004" }, files_id : { "$oid" : "000000000000000000000004" }, n : 1, data : { $hex : "55667788" } }
+
+tests:
+    -
+        description: "Delete when length is 0"
+        act:
+            operation: delete
+            arguments:
+                id: { "$oid" : "000000000000000000000001" }
+        assert:
+            result: void
+            data:
+                -
+                    { delete : "expected.files", deletes : [
+                        { q : { _id : { "$oid" : "000000000000000000000001" } }, limit : 1 }
+                    ] }                           
+    -
+        description: "Delete when length is 0 and there is one extra empty chunk"
+        act:
+            operation: delete
+            arguments:
+                id: { "$oid" : "000000000000000000000002" }
+        assert:
+            result: void
+            data:
+                -
+                    { delete : "expected.files", deletes : [
+                        { q : { _id : { "$oid" : "000000000000000000000002" } }, limit : 1 }
+                    ] }
+                -
+                    { delete : "expected.chunks", deletes : [
+                        { q : { files_id : { "$oid" : "000000000000000000000002" } }, limit : 0 }
+                    ] }
+    -
+        description: "Delete when length is 8"
+        act:
+            operation: delete
+            arguments:
+                id: { "$oid" : "000000000000000000000004" }
+        assert:
+            result: void
+            data:
+                -
+                    { delete : "expected.files", deletes : [
+                        { q : { _id : { "$oid" : "000000000000000000000004" } }, limit : 1 }
+                    ] }
+                -
+                    { delete : "expected.chunks", deletes : [
+                        { q : { files_id : { "$oid" : "000000000000000000000004" } }, limit : 0 }
+                    ] }
+    -
+        description: "Delete when files entry does not exist"
+        act:
+            operation: delete
+            arguments:
+                id: { "$oid" : "000000000000000000000000" }
+        assert:
+            error: "FileNotFound"
+    -
+        description: "Delete when files entry does not exist and there are orphaned chunks"
+        arrange:
+            data:
+                -
+                    { delete : "fs.files", deletes : [
+                        { q : { _id : { "$oid" : "000000000000000000000004" } }, limit : 1 }
+                    ] }
+        act:
+            operation: delete
+            arguments:
+                id: { "$oid" : "000000000000000000000004" }
+        assert:
+            error: "FileNotFound"
+            data:
+                -
+                    { delete : "expected.files", deletes : [
+                        { q : { _id : { "$oid" : "000000000000000000000004" } }, limit : 1 }
+                    ] }
+                -
+                    { delete : "expected.chunks", deletes : [
+                        { q : { files_id : { "$oid" : "000000000000000000000004" } }, limit : 0 }
+                    ] }

tests/GridFS/Specification/tests/download.json

+{
+  "data": {
+    "files": [
+      {
+        "_id": {
+          "$oid": "000000000000000000000001"
+        },
+        "length": 0,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-01T00:00:00.000Z"
+        },
+        "md5": "d41d8cd98f00b204e9800998ecf8427e",
+        "filename": "length-0",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000002"
+        },
+        "length": 0,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-01T00:00:00.000Z"
+        },
+        "md5": "d41d8cd98f00b204e9800998ecf8427e",
+        "filename": "length-0-with-empty-chunk",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000003"
+        },
+        "length": 2,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-01T00:00:00.000Z"
+        },
+        "md5": "c700ed4fdb1d27055aa3faa2c2432283",
+        "filename": "length-2",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000004"
+        },
+        "length": 8,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-01T00:00:00.000Z"
+        },
+        "md5": "dd254cdc958e53abaa67da9f797125f5",
+        "filename": "length-8",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000005"
+        },
+        "length": 10,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-01T00:00:00.000Z"
+        },
+        "md5": "57d83cd477bfb1ccd975ab33d827a92b",
+        "filename": "length-10",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      }
+    ],
+    "chunks": [
+      {
+        "_id": {
+          "$oid": "000000000000000000000001"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000002"
+        },
+        "n": 0,
+        "data": {
+          "$hex": ""
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000002"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000003"
+        },
+        "n": 0,
+        "data": {
+          "$hex": "1122"
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000003"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000004"
+        },
+        "n": 0,
+        "data": {
+          "$hex": "11223344"
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000004"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000004"
+        },
+        "n": 1,
+        "data": {
+          "$hex": "55667788"
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000005"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000005"
+        },
+        "n": 0,
+        "data": {
+          "$hex": "11223344"
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000006"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000005"
+        },
+        "n": 1,
+        "data": {
+          "$hex": "55667788"
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000007"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000005"
+        },
+        "n": 2,
+        "data": {
+          "$hex": "99aa"
+        }
+      }
+    ]
+  },
+  "tests": [
+    {
+      "description": "Download when length is zero",
+      "act": {
+        "operation": "download",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000001"
+          },
+          "options": {
+          }
+        }
+      },
+      "assert": {
+        "result": {
+          "$hex": ""
+        }
+      }
+    },
+    {
+      "description": "Download when length is zero and there is one empty chunk",
+      "act": {
+        "operation": "download",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000002"
+          },
+          "options": {
+          }
+        }
+      },
+      "assert": {
+        "result": {
+          "$hex": ""
+        }
+      }
+    },
+    {
+      "description": "Download when there is one chunk",
+      "act": {
+        "operation": "download",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000003"
+          },
+          "options": {
+          }
+        }
+      },
+      "assert": {
+        "result": {
+          "$hex": "1122"
+        }
+      }
+    },
+    {
+      "description": "Download when there are two chunks",
+      "act": {
+        "operation": "download",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000004"
+          },
+          "options": {
+          }
+        }
+      },
+      "assert": {
+        "result": {
+          "$hex": "1122334455667788"
+        }
+      }
+    },
+    {
+      "description": "Download when there are three chunks",
+      "act": {
+        "operation": "download",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000005"
+          },
+          "options": {
+          }
+        }
+      },
+      "assert": {
+        "result": {
+          "$hex": "112233445566778899aa"
+        }
+      }
+    },
+    {
+      "description": "Download when files entry does not exist",
+      "act": {
+        "operation": "download",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000000"
+          },
+          "options": {
+          }
+        }
+      },
+      "assert": {
+        "error": "FileNotFound"
+      }
+    },
+    {
+      "description": "Download when an intermediate chunk is missing",
+      "arrange": {
+        "data": [
+          {
+            "delete": "fs.chunks",
+            "deletes": [
+              {
+                "q": {
+                  "files_id": {
+                    "$oid": "000000000000000000000005"
+                  },
+                  "n": 1
+                },
+                "limit": 1
+              }
+            ]
+          }
+        ]
+      },
+      "act": {
+        "operation": "download",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000005"
+          }
+        }
+      },
+      "assert": {
+        "error": "ChunkIsMissing"
+      }
+    },
+    {
+      "description": "Download when final chunk is missing",
+      "arrange": {
+        "data": [
+          {
+            "delete": "fs.chunks",
+            "deletes": [
+              {
+                "q": {
+                  "files_id": {
+                    "$oid": "000000000000000000000005"
+                  },
+                  "n": 1
+                },
+                "limit": 1
+              }
+            ]
+          }
+        ]
+      },
+      "act": {
+        "operation": "download",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000005"
+          }
+        }
+      },
+      "assert": {
+        "error": "ChunkIsMissing"
+      }
+    },
+    {
+      "description": "Download when an intermediate chunk is the wrong size",
+      "arrange": {
+        "data": [
+          {
+            "update": "fs.chunks",
+            "updates": [
+              {
+                "q": {
+                  "files_id": {
+                    "$oid": "000000000000000000000005"
+                  },
+                  "n": 1
+                },
+                "u": {
+                  "$set": {
+                    "data": {
+                      "$hex": "556677"
+                    }
+                  }
+                }
+              },
+              {
+                "q": {
+                  "files_id": {
+                    "$oid": "000000000000000000000005"
+                  },
+                  "n": 2
+                },
+                "u": {
+                  "$set": {
+                    "data": {
+                      "$hex": "8899aa"
+                    }
+                  }
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "act": {
+        "operation": "download",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000005"
+          }
+        }
+      },
+      "assert": {
+        "error": "ChunkIsWrongSize"
+      }
+    },
+    {
+      "description": "Download when final chunk is the wrong size",
+      "arrange": {
+        "data": [
+          {
+            "update": "fs.chunks",
+            "updates": [
+              {
+                "q": {
+                  "files_id": {
+                    "$oid": "000000000000000000000005"
+                  },
+                  "n": 2
+                },
+                "u": {
+                  "$set": {
+                    "data": {
+                      "$hex": "99"
+                    }
+                  }
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "act": {
+        "operation": "download",
+        "arguments": {
+          "id": {
+            "$oid": "000000000000000000000005"
+          }
+        }
+      },
+      "assert": {
+        "error": "ChunkIsWrongSize"
+      }
+    }
+  ]
+}
\ No newline at end of file

tests/GridFS/Specification/tests/download.yml

+data:
+    files:
+        -
+            _id: { "$oid" : "000000000000000000000001" }
+            length: 0
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-01T00:00:00.000Z" }
+            md5: "d41d8cd98f00b204e9800998ecf8427e"
+            filename: "length-0"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+        -
+            _id: { "$oid" : "000000000000000000000002" }
+            length: 0
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-01T00:00:00.000Z" }
+            md5: "d41d8cd98f00b204e9800998ecf8427e"
+            filename: "length-0-with-empty-chunk"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+        -
+            _id: { "$oid" : "000000000000000000000003" }
+            length: 2
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-01T00:00:00.000Z" }
+            md5: "c700ed4fdb1d27055aa3faa2c2432283"
+            filename: "length-2"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+        -
+            _id: { "$oid" : "000000000000000000000004" }
+            length: 8
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-01T00:00:00.000Z" }
+            md5: "dd254cdc958e53abaa67da9f797125f5"
+            filename: "length-8"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+        -
+            _id: { "$oid" : "000000000000000000000005" }
+            length: 10
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-01T00:00:00.000Z" }
+            md5: "57d83cd477bfb1ccd975ab33d827a92b"
+            filename: "length-10"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+    chunks:
+        - { _id : { "$oid" : "000000000000000000000001" }, files_id : { "$oid" : "000000000000000000000002" }, n : 0, data : { $hex : "" } }
+        - { _id : { "$oid" : "000000000000000000000002" }, files_id : { "$oid" : "000000000000000000000003" }, n : 0, data : { $hex : "1122" } }
+        - { _id : { "$oid" : "000000000000000000000003" }, files_id : { "$oid" : "000000000000000000000004" }, n : 0, data : { $hex : "11223344" } }
+        - { _id : { "$oid" : "000000000000000000000004" }, files_id : { "$oid" : "000000000000000000000004" }, n : 1, data : { $hex : "55667788" } }
+        - { _id : { "$oid" : "000000000000000000000005" }, files_id : { "$oid" : "000000000000000000000005" }, n : 0, data : { $hex : "11223344" } }
+        - { _id : { "$oid" : "000000000000000000000006" }, files_id : { "$oid" : "000000000000000000000005" }, n : 1, data : { $hex : "55667788" } }
+        - { _id : { "$oid" : "000000000000000000000007" }, files_id : { "$oid" : "000000000000000000000005" }, n : 2, data : { $hex : "99aa" } }
+
+tests:
+    -
+        description: "Download when length is zero"
+        act:
+            operation: download
+            arguments:
+                id: { "$oid" : "000000000000000000000001" }
+                options: { }
+        assert:
+            result: { $hex : "" }
+    -
+        description: "Download when length is zero and there is one empty chunk"
+        act:
+            operation: download
+            arguments:
+                id: { "$oid" : "000000000000000000000002" }
+                options: { }
+        assert:
+            result: { $hex : "" }
+    -
+        description: "Download when there is one chunk"
+        act:
+            operation: download
+            arguments:
+                id: { "$oid" : "000000000000000000000003" }
+                options: { }
+        assert:
+            result: { $hex : "1122" }
+    -
+        description: "Download when there are two chunks"
+        act:
+            operation: download
+            arguments:
+                id: { "$oid" : "000000000000000000000004" }
+                options: { }
+        assert:
+            result: { $hex : "1122334455667788" }
+    -
+        description: "Download when there are three chunks"
+        act:
+            operation: download
+            arguments:
+                id: { "$oid" : "000000000000000000000005" }
+                options: { }
+        assert:
+            result: { $hex : "112233445566778899aa" }
+    -
+        description: "Download when files entry does not exist"
+        act:
+            operation: download
+            arguments:
+                id: { "$oid" : "000000000000000000000000" }
+                options: { }
+        assert:
+            error: "FileNotFound"
+    -
+        description: "Download when an intermediate chunk is missing"
+        arrange:
+            data:
+                -
+                    { delete : "fs.chunks", deletes : [
+                        { q : { files_id : { "$oid" : "000000000000000000000005" }, n : 1 }, limit : 1 }
+                    ] }
+        act:
+            operation: download
+            arguments:
+                id: { "$oid" : "000000000000000000000005" }
+        assert:
+            error: "ChunkIsMissing"
+    -
+        description: "Download when final chunk is missing"
+        arrange:
+            data:
+                -
+                    { delete : "fs.chunks", deletes : [
+                        { q : { files_id : { "$oid" : "000000000000000000000005" }, n : 1 }, limit : 1 }
+                    ] }
+        act:
+            operation: download
+            arguments:
+                id: { "$oid" : "000000000000000000000005" }
+        assert:
+            error: "ChunkIsMissing"
+    -
+        description: "Download when an intermediate chunk is the wrong size"
+        arrange:
+            data:
+                -
+                    { update : "fs.chunks", updates : [
+                        { q : { files_id : { "$oid" : "000000000000000000000005" }, n : 1 }, u : { $set : { data : { $hex : "556677" } } } },
+                        { q : { files_id : { "$oid" : "000000000000000000000005" }, n : 2 }, u : { $set : { data : { $hex : "8899aa" } } } }
+                    ] }
+        act:
+            operation: download
+            arguments:
+                id: { "$oid" : "000000000000000000000005" }
+        assert:
+            error: "ChunkIsWrongSize"
+    -
+        description: "Download when final chunk is the wrong size"
+        arrange:
+            data:
+                -
+                    { update : "fs.chunks", updates : [
+                        { q : { files_id : { "$oid" : "000000000000000000000005" }, n : 2 }, u : { $set : { data : { $hex : "99" } } } }
+                    ] }
+        act:
+            operation: download
+            arguments:
+                id: { "$oid" : "000000000000000000000005" }
+        assert:
+            error: "ChunkIsWrongSize"

tests/GridFS/Specification/tests/download_by_name.json

+{
+  "data": {
+    "files": [
+      {
+        "_id": {
+          "$oid": "000000000000000000000001"
+        },
+        "length": 1,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-01T00:00:00.000Z"
+        },
+        "md5": "47ed733b8d10be225eceba344d533586",
+        "filename": "abc",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000002"
+        },
+        "length": 1,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-02T00:00:00.000Z"
+        },
+        "md5": "b15835f133ff2e27c7cb28117bfae8f4",
+        "filename": "abc",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000003"
+        },
+        "length": 1,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-03T00:00:00.000Z"
+        },
+        "md5": "eccbc87e4b5ce2fe28308fd9f2a7baf3",
+        "filename": "abc",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000004"
+        },
+        "length": 1,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-04T00:00:00.000Z"
+        },
+        "md5": "f623e75af30e62bbd73d6df5b50bb7b5",
+        "filename": "abc",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000005"
+        },
+        "length": 1,
+        "chunkSize": 4,
+        "uploadDate": {
+          "$date": "1970-01-05T00:00:00.000Z"
+        },
+        "md5": "4c614360da93c0a041b22e537de151eb",
+        "filename": "abc",
+        "contentType": "application/octet-stream",
+        "aliases": [
+
+        ],
+        "metadata": {
+        }
+      }
+    ],
+    "chunks": [
+      {
+        "_id": {
+          "$oid": "000000000000000000000001"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000001"
+        },
+        "n": 0,
+        "data": {
+          "$hex": "11"
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000002"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000002"
+        },
+        "n": 0,
+        "data": {
+          "$hex": "22"
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000003"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000003"
+        },
+        "n": 0,
+        "data": {
+          "$hex": "33"
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000004"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000004"
+        },
+        "n": 0,
+        "data": {
+          "$hex": "44"
+        }
+      },
+      {
+        "_id": {
+          "$oid": "000000000000000000000005"
+        },
+        "files_id": {
+          "$oid": "000000000000000000000005"
+        },
+        "n": 0,
+        "data": {
+          "$hex": "55"
+        }
+      }
+    ]
+  },
+  "tests": [
+    {
+      "description": "Download_by_name when revision is 0",
+      "act": {
+        "operation": "download_by_name",
+        "arguments": {
+          "filename": "abc",
+          "options": {
+            "revision": 0
+          }
+        }
+      },
+      "assert": {
+        "result": {
+          "$hex": "11"
+        }
+      }
+    },
+    {
+      "description": "Download_by_name when revision is 1",
+      "act": {
+        "operation": "download_by_name",
+        "arguments": {
+          "filename": "abc",
+          "options": {
+            "revision": 1
+          }
+        }
+      },
+      "assert": {
+        "result": {
+          "$hex": "22"
+        }
+      }
+    },
+    {
+      "description": "Download_by_name when revision is -2",
+      "act": {
+        "operation": "download_by_name",
+        "arguments": {
+          "filename": "abc",
+          "options": {
+            "revision": -2
+          }
+        }
+      },
+      "assert": {
+        "result": {
+          "$hex": "44"
+        }
+      }
+    },
+    {
+      "description": "Download_by_name when revision is -1",
+      "act": {
+        "operation": "download_by_name",
+        "arguments": {
+          "filename": "abc",
+          "options": {
+            "revision": -1
+          }
+        }
+      },
+      "assert": {
+        "result": {
+          "$hex": "55"
+        }
+      }
+    },
+    {
+      "description": "Download_by_name when files entry does not exist",
+      "act": {
+        "operation": "download_by_name",
+        "arguments": {
+          "filename": "xyz"
+        }
+      },
+      "assert": {
+        "error": "FileNotFound"
+      }
+    },
+    {
+      "description": "Download_by_name when revision does not exist",
+      "act": {
+        "operation": "download_by_name",
+        "arguments": {
+          "filename": "abc",
+          "options": {
+            "revision": 999
+          }
+        }
+      },
+      "assert": {
+        "error": "RevisionNotFound"
+      }
+    }
+  ]
+}
\ No newline at end of file

tests/GridFS/Specification/tests/download_by_name.yml

+data:
+    files:
+        -
+            _id: { "$oid" : "000000000000000000000001" }
+            length: 1
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-01T00:00:00.000Z" }
+            md5: "47ed733b8d10be225eceba344d533586"
+            filename: "abc"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+        -
+            _id: { "$oid" : "000000000000000000000002" }
+            length: 1
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-02T00:00:00.000Z" }
+            md5: "b15835f133ff2e27c7cb28117bfae8f4"
+            filename: "abc"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+        -
+            _id: { "$oid" : "000000000000000000000003" }
+            length: 1
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-03T00:00:00.000Z" }
+            md5: "eccbc87e4b5ce2fe28308fd9f2a7baf3"
+            filename: "abc"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+        -
+            _id: { "$oid" : "000000000000000000000004" }
+            length: 1
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-04T00:00:00.000Z" }
+            md5: "f623e75af30e62bbd73d6df5b50bb7b5"
+            filename: "abc"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+        -
+            _id: { "$oid" : "000000000000000000000005" }
+            length: 1
+            chunkSize: 4
+            uploadDate: { "$date" : "1970-01-05T00:00:00.000Z" }
+            md5: "4c614360da93c0a041b22e537de151eb"
+            filename: "abc"
+            contentType: "application/octet-stream"
+            aliases: []
+            metadata: {}
+    chunks:
+        - { _id : { "$oid" : "000000000000000000000001" }, files_id : { "$oid" : "000000000000000000000001" }, n : 0, data : { $hex : "11" } }
+        - { _id : { "$oid" : "000000000000000000000002" }, files_id : { "$oid" : "000000000000000000000002" }, n : 0, data : { $hex : "22" } }
+        - { _id : { "$oid" : "000000000000000000000003" }, files_id : { "$oid" : "000000000000000000000003" }, n : 0, data : { $hex : "33" } }
+        - { _id : { "$oid" : "000000000000000000000004" }, files_id : { "$oid" : "000000000000000000000004" }, n : 0, data : { $hex : "44" } }
+        - { _id : { "$oid" : "000000000000000000000005" }, files_id : { "$oid" : "000000000000000000000005" }, n : 0, data : { $hex : "55" } }
+
+tests:
+    -
+        description: "Download_by_name when revision is 0"
+        act:
+            operation: download_by_name
+            arguments:
+                filename: "abc"
+                options: { revision : 0 }
+        assert:
+            result: { $hex : "11" }
+    -
+        description: "Download_by_name when revision is 1"
+        act:
+            operation: download_by_name
+            arguments:
+                filename: "abc"
+                options: { revision : 1 }
+        assert:
+            result: { $hex : "22" }
+    -
+        description: "Download_by_name when revision is -2"
+        act:
+            operation: download_by_name
+            arguments:
+                filename: "abc"
+                options: { revision : -2 }
+        assert:
+            result: { $hex : "44" }
+    -
+        description: "Download_by_name when revision is -1"
+        act:
+            operation: download_by_name
+            arguments:
+                filename: "abc"
+                options: { revision : -1 }
+        assert:
+            result: { $hex : "55" }
+    -
+        description: "Download_by_name when files entry does not exist"
+        act:
+            operation: download_by_name
+            arguments:
+                filename: "xyz"
+        assert:
+            error: "FileNotFound"
+    -
+        description: "Download_by_name when revision does not exist"
+        act:
+            operation: download_by_name
+            arguments:
+                filename: "abc"
+                options: { revision : 999 }
+        assert:
+            error: "RevisionNotFound"

tests/GridFS/Specification/tests/upload.json

+{
+  "data": {
+    "files": [
+
+    ],
+    "chunks": [
+
+    ]
+  },
+  "tests": [
+    {
+      "description": "Upload when length is 0",
+      "act": {
+        "operation": "upload",
+        "arguments": {
+          "filename": "filename",
+          "source": {
+            "$hex": ""
+          },
+          "options": {
+            "chunkSizeBytes": 4
+          }
+        }
+      },
+      "assert": {
+        "result": "&result",
+        "data": [
+          {
+            "insert": "expected.files",
+            "documents": [
+              {
+                "_id": "*result",
+                "length": 0,
+                "chunkSize": 4,
+                "uploadDate": "*actual",
+                "md5": "d41d8cd98f00b204e9800998ecf8427e",
+                "filename": "filename"
+              }
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "description": "Upload when length is 1",
+      "act": {
+        "operation": "upload",
+        "arguments": {
+          "filename": "filename",
+          "source": {
+            "$hex": "11"
+          },
+          "options": {
+            "chunkSizeBytes": 4
+          }
+        }
+      },
+      "assert": {
+        "result": "&result",
+        "data": [
+          {
+            "insert": "expected.files",
+            "documents": [
+              {
+                "_id": "*result",
+                "length": 1,
+                "chunkSize": 4,
+                "uploadDate": "*actual",
+                "md5": "47ed733b8d10be225eceba344d533586",
+                "filename": "filename"
+              }
+            ]
+          },
+          {
+            "insert": "expected.chunks",
+            "documents": [
+              {
+                "_id": "*actual",
+                "files_id": "*result",
+                "n": 0,
+                "data": {
+                  "$hex": "11"
+                }
+              }
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "description": "Upload when length is 3",
+      "act": {
+        "operation": "upload",
+        "arguments": {
+          "filename": "filename",
+          "source": {
+            "$hex": "112233"
+          },
+          "options": {
+            "chunkSizeBytes": 4
+          }
+        }
+      },
+      "assert": {
+        "result": "&result",
+        "data": [
+          {
+            "insert": "expected.files",
+            "documents": [
+              {
+                "_id": "*result",
+                "length": 3,
+                "chunkSize": 4,
+                "uploadDate": "*actual",
+                "md5": "bafae3a174ab91fc70db7a6aa50f4f52",
+                "filename": "filename"
+              }
+            ]
+          },
+          {
+            "insert": "expected.chunks",
+            "documents": [
+              {
+                "_id": "*actual",
+                "files_id": "*result",
+                "n": 0,
+                "data": {
+                  "$hex": "112233"
+                }
+              }
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "description": "Upload when length is 4",
+      "act": {
+        "operation": "upload",
+        "arguments": {
+          "filename": "filename",
+          "source": {
+            "$hex": "11223344"
+          },
+          "options": {
+            "chunkSizeBytes": 4
+          }
+        }
+      },
+      "assert": {
+        "result": "&result",
+        "data": [
+          {
+            "insert": "expected.files",
+            "documents": [
+              {
+                "_id": "*result",
+                "length": 4,
+                "chunkSize": 4,
+                "uploadDate": "*actual",
+                "md5": "7e7c77cff5705d1f7574a25ef6662117",
+                "filename": "filename"
+              }
+            ]
+          },
+          {
+            "insert": "expected.chunks",
+            "documents": [
+              {
+                "_id": "*actual",
+                "files_id": "*result",
+                "n": 0,
+                "data": {
+                  "$hex": "11223344"
+                }
+              }
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "description": "Upload when length is 5",
+      "act": {
+        "operation": "upload",
+        "arguments": {
+          "filename": "filename",
+          "source": {
+            "$hex": "1122334455"
+          },
+          "options": {
+            "chunkSizeBytes": 4
+          }
+        }
+      },
+      "assert": {
+        "result": "&result",
+        "data": [
+          {
+            "insert": "expected.files",
+            "documents": [
+              {
+                "_id": "*result",
+                "length": 5,
+                "chunkSize": 4,
+                "uploadDate": "*actual",
+                "md5": "283d4fea5dded59cf837d3047328f5af",
+                "filename": "filename"
+              }
+            ]
+          },
+          {
+            "insert": "expected.chunks",
+            "documents": [
+              {
+                "_id": "*actual",
+                "files_id": "*result",
+                "n": 0,
+                "data": {
+                  "$hex": "11223344"
+                }
+              },
+              {
+                "_id": "*actual",
+                "files_id": "*result",
+                "n": 1,
+                "data": {
+                  "$hex": "55"
+                }
+              }
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "description": "Upload when length is 8",
+      "act": {
+        "operation": "upload",
+        "arguments": {
+          "filename": "filename",
+          "source": {
+            "$hex": "1122334455667788"
+          },
+          "options": {
+            "chunkSizeBytes": 4
+          }
+        }
+      },
+      "assert": {
+        "result": "&result",
+        "data": [
+          {
+            "insert": "expected.files",
+            "documents": [
+              {
+                "_id": "*result",
+                "length": 8,
+                "chunkSize": 4,
+                "uploadDate": "*actual",
+                "md5": "dd254cdc958e53abaa67da9f797125f5",
+                "filename": "filename"
+              }
+            ]
+          },
+          {
+            "insert": "expected.chunks",
+            "documents": [
+              {
+                "_id": "*actual",
+                "files_id": "*result",
+                "n": 0,
+                "data": {
+                  "$hex": "11223344"
+                }
+              },
+              {
+                "_id": "*actual",
+                "files_id": "*result",
+                "n": 1,
+                "data": {
+                  "$hex": "55667788"
+                }
+              }
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "description": "Upload when contentType is provided",
+      "act": {
+        "operation": "upload",
+        "arguments": {
+          "filename": "filename",
+          "source": {
+            "$hex": "11"
+          },
+          "options": {
+            "chunkSizeBytes": 4,
+            "contentType": "image/jpeg"
+          }
+        }
+      },
+      "assert": {
+        "result": "&result",
+        "data": [
+          {
+            "insert": "expected.files",
+            "documents": [
+              {
+                "_id": "*result",
+                "length": 1,
+                "chunkSize": 4,
+                "uploadDate": "*actual",
+                "md5": "47ed733b8d10be225eceba344d533586",
+                "filename": "filename",
+                "contentType": "image/jpeg"
+              }
+            ]
+          },
+          {
+            "insert": "expected.chunks",
+            "documents": [
+              {
+                "_id": "*actual",
+                "files_id": "*result",
+                "n": 0,
+                "data": {
+                  "$hex": "11"
+                }
+              }
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "description": "Upload when metadata is provided",
+      "act": {
+        "operation": "upload",
+        "arguments": {
+          "filename": "filename",
+          "source": {
+            "$hex": "11"
+          },
+          "options": {
+            "chunkSizeBytes": 4,
+            "metadata": {
+              "x": 1
+            }
+          }
+        }
+      },
+      "assert": {
+        "result": "&result",
+        "data": [
+          {
+            "insert": "expected.files",
+            "documents": [
+              {
+                "_id": "*result",
+                "length": 1,
+                "chunkSize": 4,
+                "uploadDate": "*actual",
+                "md5": "47ed733b8d10be225eceba344d533586",
+                "filename": "filename",
+                "metadata": {
+                  "x": 1
+                }
+              }
+            ]
+          },
+          {
+            "insert": "expected.chunks",
+            "documents": [
+              {
+                "_id": "*actual",
+                "files_id": "*result",
+                "n": 0,
+                "data": {
+                  "$hex": "11"
+                }
+              }
+            ]
+          }
+        ]
+      }
+    }
+  ]
+}
\ No newline at end of file

tests/GridFS/Specification/tests/upload.yml

+data:
+    files: []
+    chunks: []
+
+tests:
+    -
+        description: "Upload when length is 0"
+        act:
+            operation: upload
+            arguments:
+                filename: "filename"
+                source: { $hex : "" }
+                options: { chunkSizeBytes : 4 }
+        assert:
+            result: "&result"
+            data:
+                -
+                    { insert : "expected.files", documents : [
+                        { _id : "*result",  length : 0, chunkSize : 4, uploadDate : "*actual", md5 : "d41d8cd98f00b204e9800998ecf8427e", filename : "filename" }
+                    ] }
+    -
+        description: "Upload when length is 1"
+        act:
+            operation: upload
+            arguments:
+                filename: "filename"
+                source: { $hex : "11" }
+                options: { chunkSizeBytes : 4 }
+        assert:
+            result: "&result"
+            data:
+                -
+                    { insert : "expected.files", documents : [
+                        { _id : "*result", length : 1, chunkSize : 4, uploadDate : "*actual", md5 : "47ed733b8d10be225eceba344d533586", filename : "filename" }
+                    ] }
+                -
+                    { insert : "expected.chunks", documents : [
+                        { _id : "*actual", files_id : "*result", n : 0, data : { $hex : "11" } }
+                    ] }
+    -
+        description: "Upload when length is 3"
+        act:
+            operation: upload
+            arguments:
+                filename: "filename"
+                source: { $hex : "112233" }
+                options: { chunkSizeBytes : 4 }
+        assert:
+            result: "&result"
+            data:
+                -
+                    { insert : "expected.files", documents : [
+                        { _id : "*result",  length : 3,  chunkSize : 4, uploadDate : "*actual",  md5 : "bafae3a174ab91fc70db7a6aa50f4f52",  filename : "filename" }
+                    ] }
+                -
+                    { insert : "expected.chunks", documents : [
+                        { _id : "*actual", files_id : "*result", n : 0, data : { $hex : "112233" } }
+                    ] }
+    -
+        description: "Upload when length is 4"
+        act:
+            operation: upload
+            arguments:
+                filename: "filename"
+                source: { $hex : "11223344" }
+                options: { chunkSizeBytes : 4 }
+        assert:
+            result: "&result"
+            data:
+                -
+                    { insert : "expected.files", documents : [
+                        { _id : "*result", length : 4, chunkSize : 4, uploadDate : "*actual", md5 : "7e7c77cff5705d1f7574a25ef6662117", filename : "filename" }
+                    ] }
+                -
+                    { insert : "expected.chunks", documents : [
+                        { _id : "*actual", files_id : "*result", n : 0, data : { $hex : "11223344" } }
+                    ] }
+    -
+        description: "Upload when length is 5"
+        act:
+            operation: upload
+            arguments:
+                filename: "filename"
+                source: { $hex : "1122334455" }
+                options: { chunkSizeBytes : 4 }
+        assert:
+            result: "&result"
+            data:
+                -
+                    { insert : "expected.files", documents : [
+                        { _id : "*result", length : 5, chunkSize : 4, uploadDate : "*actual", md5 : "283d4fea5dded59cf837d3047328f5af", filename : "filename" }
+                    ] }
+                -
+                    { insert : "expected.chunks", documents : [
+                        { _id : "*actual", files_id : "*result", n : 0, data : { $hex : "11223344" } },
+                        { _id : "*actual", files_id : "*result", n : 1, data : { $hex : "55" } }
+                    ] }
+    -
+        description: "Upload when length is 8"
+        act:
+            operation: upload
+            arguments:
+                filename: "filename"
+                source: { $hex : "1122334455667788" }
+                options: { chunkSizeBytes : 4 }
+        assert:
+            result: "&result"
+            data:
+                -
+                    { insert : "expected.files", documents : [
+                        { _id : "*result", length : 8, chunkSize : 4, uploadDate : "*actual", md5 : "dd254cdc958e53abaa67da9f797125f5", filename : "filename" }
+
+                    ] }
+                -
+                    { insert : "expected.chunks", documents : [
+                        { _id : "*actual", files_id : "*result", n : 0, data : { $hex : "11223344" } },
+                        { _id : "*actual", files_id : "*result", n : 1, data : { $hex : "55667788" } }
+                    ] }
+    -
+        description: "Upload when contentType is provided"
+        act:
+            operation: upload
+            arguments:
+                filename: "filename"
+                source: { $hex : "11" }
+                options: { chunkSizeBytes : 4, contentType : "image/jpeg" }
+        assert:
+            result: "&result"
+            data:
+                -
+                    { insert : "expected.files", documents : [
+                        { _id : "*result", length : 1, chunkSize : 4, uploadDate : "*actual", md5 : "47ed733b8d10be225eceba344d533586", filename : "filename", contentType : "image/jpeg" }
+                    ] }
+                -
+                    { insert : "expected.chunks", documents : [
+                        { _id : "*actual", files_id : "*result", n : 0, data : { $hex : "11" } }
+                    ] }
+    -
+        description: "Upload when metadata is provided"
+        act:
+            operation: upload
+            arguments:
+                filename: "filename"
+                source: { $hex : "11" }
+                options:
+                    chunkSizeBytes: 4
+                    metadata: { x : 1 }
+        assert:
+            result: "&result"
+            data:
+                -
+                    { insert : "expected.files", documents : [
+                        { _id : "*result", length : 1, chunkSize : 4, uploadDate : "*actual", md5 : "47ed733b8d10be225eceba344d533586", filename : "filename", metadata : { x : 1 } }
+                    ] }
+                -
+                    { insert : "expected.chunks", documents : [
+                        { _id : "*actual", files_id : "*result", n : 0, data : { $hex : "11" } }
+                    ] }