Support creating and deleting indexes, and creating items in ElasticSearch

composer.json

@@ -6,14 +6,24 @@
         {
             "name": "Jan Wyszynski",
             "email": "jan.wyszynki@gmail.com"
+        },
+        {
+            "name": "Willem Viljoen",
+            "email": "willemnviljoen@gmail.com"
         }
     ],
     "require": {
-        "elasticsearch/elasticsearch": "~1.0"
+        "elasticsearch/elasticsearch": "~1.0",
+        "codeception/codeception": "^2.1"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "~4.8",
+        "mockery/mockery": "~0.9"
     },
     "autoload": {
         "psr-4": {
-            "Codeception\\Module\\": "src"
+            "Codeception\\Module\\": "src",
+            "Tests\\Codeception\\Module\\": "tests"
         }
     }
 }

src/ElasticSearch.php

@@ -5,38 +5,79 @@
 
 namespace Codeception\Module;
 
+use Codeception\Lib\ModuleContainer;
 use Codeception\Module;
 use Elasticsearch\Client;
 
 class ElasticSearch extends Module
 {
-    /** @var  \Elasticsearch\Client */
-    private $elasticSearch;
+    /**
+     * @var Client
+     */
+    private $elasticSearch = null;
 
-    public function __construct($config = null)
+    public function __construct(ModuleContainer $moduleContainer, $config = null, Client $client = null)
     {
-        // terminology: see = isXyz => true/false, have = create, grab = get => data
+        $this->setModuleConfiguration($config);
+        $this->sanitizeModuleConfiguration();
+        $this->setElasticSearchClient($client);
+
+        parent::__construct($moduleContainer);
+    }
 
-        if (!isset($config['hosts'])) {
+    /**
+     * @param $config
+     */
+    private function setModuleConfiguration($config)
+    {
+        $this->config = $config;
+    }
+
+    private function sanitizeModuleConfiguration()
+    {
+        $this->guardThatConfigurationHasHosts();
+        $this->wrapConfiguredHostsInArrayIfNeeded();
+    }
+
+    private function guardThatConfigurationHasHosts()
+    {
+        if (!isset($this->config['hosts'])) {
             throw new \Exception('please configure hosts for ElasticSearch codeception module');
         }
+    }
 
-        if (isset($config['hosts']) && !is_array($config['hosts'])) {
-            $config['hosts'] = array($config['hosts']);
+    private function wrapConfiguredHostsInArrayIfNeeded()
+    {
+        if (!is_array($this->config['hosts'])) {
+            $this->config['hosts'] = array($this->config['hosts']);
         }
-        $this->config = (array)$config;
+    }
 
-        parent::__construct();
+    /**
+     * @param Client $client
+     */
+    private function setElasticSearchClient($client)
+    {
+        $this->elasticSearch = $client;
     }
 
     public function _initialize()
     {
-        /*
-         * elastic search config
-         * hosts - array of ES hosts
-         * dic - ES dictionary
-         */
+        if ($this->doesNotHaveElasticSearchClient()) {
+            $this->buildElasticSearchClient();
+        }
+    }
 
+    /**
+     * @return bool
+     */
+    private function doesNotHaveElasticSearchClient()
+    {
+        return is_null($this->elasticSearch);
+    }
+
+    private function buildElasticSearchClient()
+    {
         $this->elasticSearch = new Client($this->config);
     }
 
@@ -49,7 +90,7 @@ public function _initialize()
      *
      * @return array
      */
-    public function seeItemExistsInElasticsearch($index, $type, $id)
+    public function seeItemExistsInElasticSearch($index, $type, $id)
     {
         return $this->elasticSearch->exists(
             [
@@ -60,7 +101,6 @@ public function seeItemExistsInElasticsearch($index, $type, $id)
         );
     }
 
-
     /**
      * grab an item from search index
      *
@@ -70,7 +110,7 @@ public function seeItemExistsInElasticsearch($index, $type, $id)
      *
      * @return array
      */
-    public function grabAnItemFromElasticsearch($index = null, $type = null, $queryString = '*')
+    public function grabAnItemFromElasticSearch($index = null, $type = null, $queryString = '*')
     {
         $result = $this->elasticSearch->search(
             [
@@ -81,10 +121,68 @@ public function grabAnItemFromElasticsearch($index = null, $type = null, $queryS
             ]
         );
 
-        return !empty($result['hits']['hits'])
-            ? $result['hits']['hits'][0]['_source']
-            : array();
+        if ($this->isEmptyResult($result)) {
+            return array();
+        }
+
+        return $this->getFirstItemFromResult($result);
     }
 
+    /**
+     * @param $result
+     * @return bool
+     */
+    private function isEmptyResult($result)
+    {
+        return empty($result['hits']['hits']);
+    }
+
+    /**
+     * @param $result
+     * @return mixed
+     */
+    private function getFirstItemFromResult($result)
+    {
+        return $result['hits']['hits'][0]['_source'];
+    }
+
+    public function getHosts()
+    {
+        return $this->config['hosts'];
+    }
+
+    public function createIndexInElasticSearch($indexName)
+    {
+        $this->elasticSearch->indices()->create(['index' => $indexName]);
+    }
 
+    public function deleteIndexInElasticSearch($indexName)
+    {
+        $this->elasticSearch->indices()->delete(['index' => $indexName]);
+    }
+
+    public function seeIndexExistsInElasticSearch($indexName)
+    {
+        $this->assertTrue($this->elasticSearch->indices()->exists(['index' => $indexName]));
+    }
+
+    public function dontSeeIndexExistsInElasticSearch($indexName)
+    {
+        $this->assertFalse($this->elasticSearch->indices()->exists(['index' => $indexName]));
+    }
+
+    public function indexAnItemInElasticSearch($indexName, $documentType, $documentBody, $id = null)
+    {
+        $params = [
+            'index' => $indexName,
+            'type' => $documentType,
+            'body' => $documentBody
+        ];
+
+        if (!is_null($id)) {
+            $params['id'] = $id;
+        }
+
+        $this->elasticSearch->index($params);
+    }
 }

tests/ElasticSearchConfigurationTest.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Tests\Codeception\Module;
+
+use Codeception\Module\ElasticSearch;
+
+/**
+ * Created by PhpStorm.
+ * User: willemv
+ * Date: 2015/11/24
+ * Time: 14:10
+ */
+class ElasticSearchConfigurationTest extends ElasticSearchTestCase
+{
+    /**
+     * @test
+     * @expectedException \Exception
+     * @expectedExceptionMessage please configure hosts for ElasticSearch codeception module
+     */
+    public function shouldNotInstantiateWithoutConfigArray()
+    {
+        new ElasticSearch($this->container, null);
+    }
+
+    /**
+     * @test
+     */
+    public function shouldEncapsulateHostsInArrayIfNotEncapsulated()
+    {
+        $module = new ElasticSearch($this->container, ['hosts' => 'test.host.com']);
+        $hosts = $module->getHosts();
+        $this->assertEquals('test.host.com', $hosts[0]);
+    }
+
+    /**
+     * @test
+     * @expectedException \Exception
+     * @expectedExceptionMessage Could not resolve host: test.3.1415.nonexistent-host.com
+     * @fixme Find a way to test this without having to rely on an exception from across the boundary
+     */
+    public function initializeShouldCreateClientWithConfiguredHostsIfNoClientIsPassedToConstructor()
+    {
+        $module = new ElasticSearch($this->container, ['hosts' => ['test.3.1415.nonexistent-host.com']]);
+        $module->_initialize();
+        $module->seeItemExistsInElasticsearch('any-indexname', 'any-type', 'any-id');
+    }
+}

tests/ElasticSearchIndexManagementTest.php

@@ -0,0 +1,94 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: willemv
+ * Date: 2015/11/24
+ * Time: 14:19
+ */
+
+namespace Tests\Codeception\Module;
+
+
+use Elasticsearch\Namespaces\IndicesNamespace;
+use Mockery as m;
+
+class ElasticSearchIndexManagementTest extends ElasticSearchTestCase
+{
+    /** @var IndicesNamespace | m\Mock */
+    private $indicesNamespace;
+
+    /**
+     * @test
+     */
+    public function createIndexInElasticsearchShouldCallCreateOnClientIndicesWithIndexName()
+    {
+        $this->module->createIndexInElasticsearch('index-name');
+        $this->indicesNamespace->shouldHaveReceived('create')->with(m::subset(['index' => 'index-name']));
+    }
+
+    /**
+     * @test
+     */
+    public function deleteIndexInElasticsearchShouldCallDeleteOnClientIndicesWithIndexName()
+    {
+        $this->module->deleteIndexInElasticsearch('index-name');
+        $this->indicesNamespace->shouldHaveReceived('delete')->with(m::subset(['index' => 'index-name']));
+    }
+
+    /**
+     * @test
+     */
+    public function seeIndexExistsInElasticsearchShouldCallExistsOnClientIndicesWithIndexName()
+    {
+        $this->module->seeIndexExistsInElasticsearch('index-name');
+        $this->indicesNamespace->shouldHaveReceived('exists')->with(m::subset(['index' => 'index-name']));
+    }
+
+    /**
+     * @test
+     */
+    public function seeIndexExistsInElasticsearchShouldDoNothingIfIndexExists()
+    {
+        $this->indicesNamespace->shouldReceive('exists')->andReturn(true);
+        $this->module->seeIndexExistsInElasticsearch('index-name');
+    }
+
+    /**
+     * @test
+     * @expectedException \PHPUnit_Framework_ExpectationFailedException
+     */
+    public function seeIndexExistsInElasticsearchShouldHaveFailingAssertionIfIndexDoesNot()
+    {
+        $this->indicesNamespace->shouldReceive('exists')->andReturn(false);
+        $this->module->seeIndexExistsInElasticsearch('index-name');
+    }
+
+    /**
+     * @test
+     */
+    public function dontSeeIndexExistsInElasticsearchShouldDoNothingIfIndexDoesNotExist()
+    {
+        $this->indicesNamespace->shouldReceive('exists')->andReturn(false);
+        $this->module->dontSeeIndexExistsInElasticsearch('index-name');
+    }
+
+    /**
+     * @test
+     * @expectedException \PHPUnit_Framework_ExpectationFailedException
+     */
+    public function dontSeeIndexExistsInElasticsearchShouldHaveFailingAssertionIfIndexExists()
+    {
+        $this->indicesNamespace->shouldReceive('exists')->andReturn(true);
+        $this->module->dontSeeIndexExistsInElasticsearch('index-name');
+    }
+
+    public function setUp()
+    {
+        parent::setUp();
+
+        $this->indicesNamespace = m::mock('\Elasticsearch\Namespaces\IndicesNamespace');
+        $this->indicesNamespace->shouldReceive('exists')->andReturn(true)->byDefault();
+        $this->indicesNamespace->shouldIgnoreMissing();
+        $this->client->shouldReceive('indices')->andReturn($this->indicesNamespace)->byDefault();
+    }
+}