Too much stuff.

Author: martin-helmich

LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Martin Helmich <[email protected]>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

README.md

@@ -0,0 +1,62 @@
+# MongoDB mock classes
+
+## Author and license
+
+Martin Helmich
+This library is [MIT-licenced](LICENSE.txt).
+
+## Synopsis and motivation
+
+This class contains an implementation of the `MongoDB/Collection` class that
+can store, modify and filter documents in memory, together with a set of
+(optional) PHPUnit assertions.
+
+I wrote this library because I wanted to unit-test a library that used MongoDB
+collections intensively and felt that mocking the `MongoDB/Collection` class
+using PHPUnit's built-in mock builders was too restrictive.
+
+**Note**: Currently, this implementation contains only a subset of the actual
+MongoDB collection API. I've only implemented the parts of the API that I needed
+for my use case. If you need additional functionality, feel free to open an
+issue, or (better yet) a pull request.
+
+## Usage
+
+You can use this class exactly as you'd use the `MongoDB/Collection` class
+(in theory, at least -- remember, this package is not API-complete):
+
+```php
+use Helmich\MongoMock\MockCollection;
+
+$collection = new MockCollection();
+$collection->createIndex(['foo' => 1]);
+
+$documentId = $collection->insertOne(['foo' => 'bar'])->insertedId();
+$collection->updateOne(['_id' => $documentId], ['$set' => ['foo' => 'baz']]);
+```
+
+## Differences
+
+In some aspects, the `MongoDB\Collection`'s API was extended to allow for better
+testability:
+
+1.  Filter operands may contain callback functions that are applied to document
+    properties:
+
+    ```php
+    $r = $collection->find([
+        'someProperty' => function($p) {
+            return $p == 'bar';
+        }
+    ]);
+    ```
+
+2.  Filter operands may contain PHPUnit constraints (meaning instances of the
+    `PHPUnit_Framework_Constraint` class). You can easily build these using the
+    factory functions in the `PHPUnit_Framework_Assert` class.
+
+    ```php
+    $r = $collection->find([
+        'someProperty' => \PHPUnit_Framework_Assert::isInstanceOf(\MongoDB\BSON\Binary::class)
+    ]);
+    ```

src/Assert.php

@@ -1,12 +1,25 @@
 <?php
 namespace Helmich\MongoMock;
 
+use Helmich\MongoMock\Assert\HasDocumentConstraint;
+use Helmich\MongoMock\Assert\IndexWasCreatedConstraint;
 use Helmich\MongoMock\Assert\QueryWasExecutedConstraint;
+use PHPUnit_Framework_Constraint as Constraint;
 
 class Assert
 {
-    public static function executedQuery($filter, $options = [])
+    public static function collectionExecutedQuery(array $filter, array $options = []): Constraint
     {
         return new QueryWasExecutedConstraint($filter, $options);
     }
+
+    public static function collectionHasIndex(array $key, array $options = []): Constraint
+    {
+        return new IndexWasCreatedConstraint($key, $options);
+    }
+
+    public static function collectionHasDocument(array $filter = []): Constraint
+    {
+        return new HasDocumentConstraint($filter);
+    }
 }

src/Assert/HasDocumentConstraint.php

@@ -0,0 +1,39 @@
+<?php
+namespace Helmich\MongoMock\Assert;
+
+use Helmich\MongoMock\Log\Index;
+use Helmich\MongoMock\MockCollection;
+
+class HasDocumentConstraint extends \PHPUnit_Framework_Constraint
+{
+
+    /**
+     * @var
+     */
+    private $filter;
+
+    public function __construct($filter)
+    {
+        parent::__construct();
+        $this->filter = $filter;
+    }
+
+    protected function matches($other)
+    {
+        if (!$other instanceof MockCollection) {
+            return false;
+        }
+
+        return $other->count($this->filter) > 0;
+    }
+
+    /**
+     * Returns a string representation of the object.
+     *
+     * @return string
+     */
+    public function toString()
+    {
+        return 'has document that matches ' . json_encode($this->filter);
+    }
+}

src/Assert/IndexWasCreatedConstraint.php

@@ -0,0 +1,52 @@
+<?php
+namespace Helmich\MongoMock\Assert;
+
+use Helmich\MongoMock\Log\Index;
+use Helmich\MongoMock\MockCollection;
+
+class IndexWasCreatedConstraint extends \PHPUnit_Framework_Constraint
+{
+
+    /**
+     * @var
+     */
+    private $key;
+    /**
+     * @var array
+     */
+    private $options;
+
+    public function __construct($key, $options = [])
+    {
+        parent::__construct();
+        $this->key = $key;
+        $this->options = $options;
+    }
+
+    protected function matches($other)
+    {
+        if (!$other instanceof MockCollection) {
+            return false;
+        }
+
+        $constraint = \PHPUnit_Framework_Assert::equalTo(new Index($this->key, $this->options));
+
+        foreach ($other->indices as $index) {
+            if ($constraint->evaluate($index, '', true)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Returns a string representation of the object.
+     *
+     * @return string
+     */
+    public function toString()
+    {
+        return 'has index of ' . json_encode($this->key);
+    }
+}

src/Assert/QueryWasExecutedConstraint.php

@@ -1,8 +1,8 @@
 <?php
 namespace Helmich\MongoMock\Assert;
 
+use Helmich\MongoMock\Log\Query;
 use Helmich\MongoMock\MockCollection;
-use Helmich\MongoMock\Query;
 
 class QueryWasExecutedConstraint extends \PHPUnit_Framework_Constraint
 {

src/Functions.php

@@ -1,6 +1,18 @@
 <?php
 
-function executedQuery($filter, $options = [])
+use PHPUnit_Framework_Constraint as Constraint;
+
+function collectionExecutedQuery(...$params): Constraint
+{
+    return \Helmich\MongoMock\Assert::collectionExecutedQuery(...$params);
+}
+
+function collectionHasIndex(...$params): Constraint
+{
+    return \Helmich\MongoMock\Assert::collectionHasIndex(...$params);
+}
+
+function collectionHasDocument(...$params): Constraint
 {
-    return \Helmich\MongoMock\Assert::executedQuery($filter, $options);
+    return \Helmich\MongoMock\Assert::collectionHasDocument(...$params);
 }

src/Log/Index.php

@@ -0,0 +1,17 @@
+<?php
+namespace Helmich\MongoMock\Log;
+
+class Index
+{
+    private $key;
+    /**
+     * @var array
+     */
+    private $options;
+
+    public function __construct($key, array $options = [])
+    {
+        $this->key = $key;
+        $this->options = $options;
+    }
+}

src/Query.php src/Log/Query.phpsrc/Query.php renamed to src/Log/Query.php

@@ -1,5 +1,5 @@
 <?php
-namespace Helmich\MongoMock;
+namespace Helmich\MongoMock\Log;
 
 class Query
 {

src/MockCollection.php

@@ -1,26 +1,48 @@
 <?php
 namespace Helmich\MongoMock;
 
+use Helmich\MongoMock\Log\Index;
+use Helmich\MongoMock\Log\Query;
+use MongoDB\BSON\Binary;
+use MongoDB\BSON\ObjectID;
 use MongoDB\Collection;
 use MongoDB\Model\BSONDocument;
 
 class MockCollection extends Collection
 {
     public $queries = [];
-
     public $documents = [];
     public $indices = [];
+    public $dropped = false;
 
     /** @noinspection PhpMissingParentConstructorInspection */
     public function __construct()
     {
-
     }
 
     public function insertOne($document, array $options = [])
     {
+        if (!isset($document['_id'])) {
+            $document['_id'] = new ObjectID();
+        }
+
+        if (!$document instanceof BSONDocument) {
+            $document = new BSONDocument($document);
+        }
+
         $document = new BSONDocument($document);
         $this->documents[] = $document;
+
+        return new MockInsertOneResult($document['_id']);
+    }
+
+    public function insertMany(array $documents, array $options = [])
+    {
+        $insertedIds = array_map(function($doc) use ($options) {
+            return $this->insertOne($doc, $options)->getInsertedId();
+        }, $documents);
+
+        return new MockInsertManyResult($insertedIds);
     }
 
     public function deleteMany($filter, array $options = [])
@@ -95,11 +117,9 @@ public function find($filter = [], array $options = [])
 
     public function findOne($filter = [], array $options = [])
     {
-        $matcher = $this->matcherFromQuery($filter);
-        foreach ($this->documents as $doc) {
-            if ($matcher($doc)) {
-                return $doc;
-            }
+        $results = $this->find($filter, $options);
+        foreach ($results as $result) {
+            return $result;
         }
         return null;
     }
@@ -118,20 +138,16 @@ public function count($filter = [], array $options = [])
 
     public function createIndex($key, array $options = [])
     {
-        $this->indices[] = ['key' => $key, 'options' => $options];
+        $this->indices[] = new Index($key, $options);
     }
 
-    public function hasIndex($key, array $options = [])
+    public function drop(array $options = [])
     {
-        foreach ($this->indices as $index) {
-            if ($index == ['key' => $key, 'options' => $options]) {
-                return true;
-            }
-        }
-        return false;
+        $this->documents = [];
+        $this->dropped = true;
     }
 
-    private function matcherFromQuery(array $query)
+    private function matcherFromQuery(array $query): callable
     {
         $matchers = [];
 
@@ -149,12 +165,24 @@ private function matcherFromQuery(array $query)
         };
     }
 
-    private function matcherFromConstraint($constraint)
+    private function matcherFromConstraint($constraint): callable
     {
         if (is_callable($constraint)) {
             return $constraint;
         }
 
+        if ($constraint instanceof \PHPUnit_Framework_Constraint) {
+            return function($val) use ($constraint): bool {
+                return $constraint->evaluate($val, '', true);
+            };
+        }
+
+        if ($constraint instanceof ObjectID) {
+            return function($val) use ($constraint): bool {
+                return ("" . $constraint) == ("" . $val);
+            };
+        }
+
         if (is_array($constraint)) {
             return function($val) use ($constraint): bool {
                 $result = true;
@@ -177,6 +205,10 @@ private function matcherFromConstraint($constraint)
         }
 
         return function($val) use ($constraint): bool {
+            if ($val instanceof Binary && is_string($constraint)) {
+                return $val->getData() == $constraint;
+            }
+
             return $val == $constraint;
         };
     }