Merge pull request #8

src/Client.php

@@ -7,10 +7,9 @@ use MongoDB\Driver\Cursor;
 use MongoDB\Driver\Manager;
 use MongoDB\Driver\ReadPreference;
 use MongoDB\Driver\WriteConcern;
+use MongoDB\Exception\UnexpectedValueException;
 use MongoDB\Model\DatabaseInfoIterator;
 use MongoDB\Model\DatabaseInfoLegacyIterator;
-use stdClass;
-use UnexpectedValueException;
 
 class Client
 {

src/Collection.php

@@ -163,7 +163,7 @@ class Collection
         foreach ($bulk as $n => $op) {
             foreach ($op as $opname => $args) {
                 if (!isset($args[0])) {
-                    throw new \InvalidArgumentException(sprintf("Missing argument#1 for '%s' (operation#%d)", $opname, $n));
+                    throw new InvalidArgumentException(sprintf("Missing argument#1 for '%s' (operation#%d)", $opname, $n));
                 }
 
                 switch ($opname) {
@@ -173,7 +173,7 @@ class Collection
 
                 case "updateMany":
                     if (!isset($args[1])) {
-                        throw new \InvalidArgumentException(sprintf("Missing argument#2 for '%s' (operation#%d)", $opname, $n));
+                        throw new InvalidArgumentException(sprintf("Missing argument#2 for '%s' (operation#%d)", $opname, $n));
                     }
                     $options = array_merge($this->getWriteOptions(), isset($args[2]) ? $args[2] : array(), array("limit" => 0));
 
@@ -182,12 +182,12 @@ class Collection
 
                 case "updateOne":
                     if (!isset($args[1])) {
-                        throw new \InvalidArgumentException(sprintf("Missing argument#2 for '%s' (operation#%d)", $opname, $n));
+                        throw new InvalidArgumentException(sprintf("Missing argument#2 for '%s' (operation#%d)", $opname, $n));
                     }
                     $options = array_merge($this->getWriteOptions(), isset($args[2]) ? $args[2] : array(), array("limit" => 1));
                     $firstKey = key($args[1]);
                     if (!isset($firstKey[0]) || $firstKey[0] != '$') {
-                        throw new \InvalidArgumentException("First key in \$update must be a \$operator");
+                        throw new InvalidArgumentException("First key in \$update must be a \$operator");
                     }
 
                     $bulk->update($args[0], $args[1], $options);
@@ -195,12 +195,12 @@ class Collection
 
                 case "replaceOne":
                     if (!isset($args[1])) {
-                        throw new \InvalidArgumentException(sprintf("Missing argument#2 for '%s' (operation#%d)", $opname, $n));
+                        throw new InvalidArgumentException(sprintf("Missing argument#2 for '%s' (operation#%d)", $opname, $n));
                     }
                     $options = array_merge($this->getWriteOptions(), isset($args[2]) ? $args[2] : array(), array("limit" => 1));
                     $firstKey = key($args[1]);
                     if (isset($firstKey[0]) && $firstKey[0] == '$') {
-                        throw new \InvalidArgumentException("First key in \$update must NOT be a \$operator");
+                        throw new InvalidArgumentException("First key in \$update must NOT be a \$operator");
                     }
 
                     $bulk->update($args[0], $args[1], $options);
@@ -217,7 +217,7 @@ class Collection
                     break;
 
                 default:
-                    throw new \InvalidArgumentException(sprintf("Unknown operation type called '%s' (operation#%d)", $opname, $n));
+                    throw new InvalidArgumentException(sprintf("Unknown operation type called '%s' (operation#%d)", $opname, $n));
                 }
             }
         }
@@ -521,7 +521,7 @@ class Collection
     {
         $firstKey = key($replacement);
         if (isset($firstKey[0]) && $firstKey[0] == '$') {
-            throw new \InvalidArgumentException("First key in \$replacement must NOT be a \$operator");
+            throw new InvalidArgumentException("First key in \$replacement must NOT be a \$operator");
         }
 
         $options = array_merge($this->getFindOneAndReplaceOptions(), $options);
@@ -559,7 +559,7 @@ class Collection
     {
         $firstKey = key($update);
         if (!isset($firstKey[0]) || $firstKey[0] != '$') {
-            throw new \InvalidArgumentException("First key in \$update must be a \$operator");
+            throw new InvalidArgumentException("First key in \$update must be a \$operator");
         }
 
         $options = array_merge($this->getFindOneAndUpdateOptions(), $options);
@@ -1036,7 +1036,7 @@ class Collection
     {
         $firstKey = key($update);
         if (isset($firstKey[0]) && $firstKey[0] == '$') {
-            throw new \InvalidArgumentException("First key in \$update must NOT be a \$operator");
+            throw new InvalidArgumentException("First key in \$update must NOT be a \$operator");
         }
         $wr = $this->_update($filter, $update, $options);
 
@@ -1078,7 +1078,7 @@ class Collection
     {
         $firstKey = key($update);
         if (!isset($firstKey[0]) || $firstKey[0] != '$') {
-            throw new \InvalidArgumentException("First key in \$update must be a \$operator");
+            throw new InvalidArgumentException("First key in \$update must be a \$operator");
         }
         $wr = $this->_update($filter, $update, $options);
 
@@ -1134,10 +1134,10 @@ class Collection
     final protected function _generateCommandException($doc)
     {
         if ($doc["errmsg"]) {
-            return new Exception($doc["errmsg"]);
+            return new RuntimeException($doc["errmsg"]);
         }
         var_dump($doc);
-        return new \Exception("FIXME: Unknown error");
+        return new RuntimeException("FIXME: Unknown error");
     }
 
     /**

src/Database.php

@@ -10,10 +10,10 @@ use MongoDB\Driver\Query;
 use MongoDB\Driver\ReadPreference;
 use MongoDB\Driver\Server;
 use MongoDB\Driver\WriteConcern;
+use MongoDB\Exception\InvalidArgumentException;
 use MongoDB\Model\CollectionInfoIterator;
 use MongoDB\Model\CollectionInfoCommandIterator;
 use MongoDB\Model\CollectionInfoLegacyIterator;
-use InvalidArgumentException;
 
 class Database
 {

src/Exception/RuntimeException.php

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

src/Exception/UnexpectedValueException.php

+<?php
+
+namespace MongoDB\Exception;
+
+class UnexpectedValueException extends \UnexpectedValueException implements Exception
+{
+}

src/Model/IndexInfo.php

@@ -35,11 +35,11 @@ class IndexInfo implements ArrayAccess
     }
 
     /**
-     * Return the index key(s).
+     * Return the index key.
      *
      * @return array
      */
-    public function getKeys()
+    public function getKey()
     {
         return (array) $this->info['key'];
     }
@@ -133,7 +133,7 @@ class IndexInfo implements ArrayAccess
      */
     public function offsetGet($key)
     {
-        return $this->data[$key];
+        return $this->info[$key];
     }
 
     /**

src/Model/IndexInput.php

@@ -3,6 +3,8 @@
 namespace MongoDB\Model;
 
 use BSON\Serializable;
+use MongoDB\Exception\InvalidArgumentException;
+use MongoDB\Exception\UnexpectedTypeException;
 
 /**
  * Index input model class.

tests/Model/CollectionInfoTest.php

+<?php
+
+namespace MongoDB\Tests;
+
+use MongoDB\Model\CollectionInfo;
+use MongoDB\Tests\TestCase;
+
+class CollectionInfoTest extends TestCase
+{
+    public function testGetName()
+    {
+        $info = new CollectionInfo(array('name' => 'foo'));
+        $this->assertSame('foo', $info->getName());
+    }
+
+    public function testGetOptions()
+    {
+        $info = new CollectionInfo(array('name' => 'foo'));
+        $this->assertSame(array(), $info->getOptions());
+
+        $info = new CollectionInfo(array('name' => 'foo', 'options' => array('capped' => true, 'size' => 1048576)));
+        $this->assertSame(array('capped' => true, 'size' => 1048576), $info->getOptions());
+    }
+
+    public function testCappedCollectionMethods()
+    {
+        $info = new CollectionInfo(array('name' => 'foo'));
+        $this->assertFalse($info->isCapped());
+        $this->assertNull($info->getCappedMax());
+        $this->assertNull($info->getCappedSize());
+
+        $info = new CollectionInfo(array('name' => 'foo', 'options' => array('capped' => true, 'size' => 1048576)));
+        $this->assertTrue($info->isCapped());
+        $this->assertNull($info->getCappedMax());
+        $this->assertSame(1048576, $info->getCappedSize());
+
+        $info = new CollectionInfo(array('name' => 'foo', 'options' => array('capped' => true, 'size' => 1048576, 'max' => 100)));
+        $this->assertTrue($info->isCapped());
+        $this->assertSame(100, $info->getCappedMax());
+        $this->assertSame(1048576, $info->getCappedSize());
+    }
+}

tests/Model/DatabaseInfoTest.php

+<?php
+
+namespace MongoDB\Tests;
+
+use MongoDB\Model\DatabaseInfo;
+use MongoDB\Tests\TestCase;
+
+class DatabaseInfoTest extends TestCase
+{
+    public function testGetName()
+    {
+        $info = new DatabaseInfo(array('name' => 'foo'));
+        $this->assertSame('foo', $info->getName());
+    }
+
+    public function testGetSizeOnDisk()
+    {
+        $info = new DatabaseInfo(array('sizeOnDisk' => '1048576'));
+        $this->assertSame(1048576, $info->getSizeOnDisk());
+    }
+
+    public function testIsEmpty()
+    {
+        $info = new DatabaseInfo(array('empty' => false));
+        $this->assertFalse($info->isEmpty());
+
+        $info = new DatabaseInfo(array('empty' => true));
+        $this->assertTrue($info->isEmpty());
+    }
+}

tests/Model/IndexInfoTest.php

+<?php
+
+namespace MongoDB\Tests;
+
+use MongoDB\Model\IndexInfo;
+use MongoDB\Tests\TestCase;
+
+class IndexInfoTest extends TestCase
+{
+    public function testBasicIndex()
+    {
+        $info = new IndexInfo(array(
+            'v' => 1,
+            'key' => array('x' => 1),
+            'name' => 'x_1',
+            'ns' => 'foo.bar',
+        ));
+
+        $this->assertSame(1, $info->getVersion());
+        $this->assertSame(array('x' => 1), $info->getKey());
+        $this->assertSame('x_1', $info->getName());
+        $this->assertSame('foo.bar', $info->getNamespace());
+        $this->assertFalse($info->isSparse());
+        $this->assertFalse($info->isTtl());
+        $this->assertFalse($info->isUnique());
+    }
+
+    public function testSparseIndex()
+    {
+        $info = new IndexInfo(array(
+            'v' => 1,
+            'key' => array('y' => 1),
+            'name' => 'y_sparse',
+            'ns' => 'foo.bar',
+            'sparse' => true,
+        ));
+
+        $this->assertSame(1, $info->getVersion());
+        $this->assertSame(array('y' => 1), $info->getKey());
+        $this->assertSame('y_sparse', $info->getName());
+        $this->assertSame('foo.bar', $info->getNamespace());
+        $this->assertTrue($info->isSparse());
+        $this->assertFalse($info->isTtl());
+        $this->assertFalse($info->isUnique());
+    }
+
+    public function testUniqueIndex()
+    {
+        $info = new IndexInfo(array(
+            'v' => 1,
+            'key' => array('z' => 1),
+            'name' => 'z_unique',
+            'ns' => 'foo.bar',
+            'unique' => true,
+        ));
+
+        $this->assertSame(1, $info->getVersion());
+        $this->assertSame(array('z' => 1), $info->getKey());
+        $this->assertSame('z_unique', $info->getName());
+        $this->assertSame('foo.bar', $info->getNamespace());
+        $this->assertFalse($info->isSparse());
+        $this->assertFalse($info->isTtl());
+        $this->assertTrue($info->isUnique());
+    }
+
+    public function testTtlIndex()
+    {
+        $info = new IndexInfo(array(
+            'v' => 1,
+            'key' => array('z' => 1),
+            'name' => 'z_unique',
+            'ns' => 'foo.bar',
+            'expireAfterSeconds' => 100,
+        ));
+
+        $this->assertSame(1, $info->getVersion());
+        $this->assertSame(array('z' => 1), $info->getKey());
+        $this->assertSame('z_unique', $info->getName());
+        $this->assertSame('foo.bar', $info->getNamespace());
+        $this->assertFalse($info->isSparse());
+        $this->assertTrue($info->isTtl());
+        $this->assertFalse($info->isUnique());
+        $this->assertTrue(isset($info['expireAfterSeconds']));
+        $this->assertSame(100, $info['expireAfterSeconds']);
+    }
+}

tests/Model/IndexInputTest.php

+<?php
+
+namespace MongoDB\Tests;
+
+use MongoDB\Model\IndexInput;
+use MongoDB\Tests\TestCase;
+
+class IndexInputTest extends TestCase
+{
+    /**
+     * @expectedException MongoDB\Exception\InvalidArgumentException
+     */
+    public function testConstructorShouldRequireKey()
+    {
+        new IndexInput(array());
+    }
+
+    /**
+     * @expectedException MongoDB\Exception\UnexpectedTypeException
+     */
+    public function testConstructorShouldRequireKeyToBeArrayOrObject()
+    {
+        new IndexInput(array('key' => 'foo'));
+    }
+
+    /**
+     * @expectedException MongoDB\Exception\UnexpectedTypeException
+     */
+    public function testConstructorShouldRequireKeyOrderToBeScalar()
+    {
+        new IndexInput(array('key' => array('x' => array())));
+    }
+
+    /**
+     * @expectedException MongoDB\Exception\InvalidArgumentException
+     */
+    public function testConstructorShouldRequireNamespace()
+    {
+        new IndexInput(array('key' => array('x' => 1)));
+    }
+
+    /**
+     * @expectedException MongoDB\Exception\UnexpectedTypeException
+     */
+    public function testConstructorShouldRequireNamespaceToBeString()
+    {
+        new IndexInput(array('key' => array('x' => 1), 'ns' => 1));
+    }
+
+    /**
+     * @expectedException MongoDB\Exception\UnexpectedTypeException
+     */
+    public function testConstructorShouldRequireNameToBeString()
+    {
+        new IndexInput(array('key' => array('x' => 1), 'ns' => 'foo.bar', 'name' => 1));
+    }
+
+    /**
+     * @dataProvider provideExpectedNameAndKey
+     */
+    public function testNameGeneration($expectedName, array $key)
+    {
+        $this->assertSame($expectedName, (string) new IndexInput(array('key' => $key, 'ns' => 'foo.bar')));
+    }
+
+    public function provideExpectedNameAndKey()
+    {
+        return array(
+            array('x_1', array('x' => 1)),
+            array('x_1_y_-1', array('x' => 1, 'y' => -1)),
+            array('loc_2dsphere', array('loc' => '2dsphere')),
+            array('loc_2dsphere_x_1', array('loc' => '2dsphere', 'x' => 1)),
+            array('doc_text', array('doc' => 'text')),
+        );
+    }
+
+    public function testBsonSerialization()
+    {
+        $expected = array(
+            'key' => array('x' => 1),
+            'ns' => 'foo.bar',
+            'name' => 'x_1',
+        );
+
+        $indexInput = new IndexInput(array(
+            'key' => array('x' => 1),
+            'ns' => 'foo.bar',
+        ));
+
+        $this->assertInstanceOf('BSON\Serializable', $indexInput);
+        $this->assertEquals($expected, $indexInput->bsonSerialize());
+    }
+}