Graviton\AnalyticsBundle\Tests\Manager\AnalyticsManagerTest

Complexity

Total Complexity

1

Size/Duplication

Total Lines	82
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	2
Bugs	0	Features	0

1 Method

Rating	Name	Duplication	Size	Complexity
A	testBuildPipeline()	0	72	1

<?php
/**
 * Testing case
 */
namespace Graviton\AnalyticsBundle\Tests\Manager;

use Graviton\AnalyticsBundle\Helper\JsonMapper;
use Graviton\AnalyticsBundle\Manager\AnalyticsManager;
use Graviton\AnalyticsBundle\Model\AnalyticModel;
use Graviton\TestBundle\Test\RestTestCase;

/**
 * @author   List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
 * @license  http://opensource.org/licenses/gpl-license.php GNU Public License
 * @link     http://swisscom.ch
 */
class AnalyticsManagerTest extends RestTestCase
{
    /**
     * Testing AnalyticsManager::parseObjectDates()
     * Testing AnalyticsManager::buildPipeline()
     * Testing JsonMapper::map()
     *
     * @return void
     */
    public function testBuildPipeline()
    {
        $analyticsManager = $this->getMockBuilder(AnalyticsManager::class)
            ->disableOriginalConstructor()
            ->setMethods(array('buildPipeline', 'parseObjectDates'))
            ->getMock();
        $buildPipeline = $this->getPrivateClassMethod(AnalyticsManager::class, 'buildPipeline');
        $mapper = new JsonMapper();
        $date = new \DateTime('-4 years');
        $year = $date->format('Y');
        $expect = '[{"$match":{"created_year":{"$gte":'.$year.'}}},{"$group":{"_id":"app-count","count":{"$sum":1}}}]';

        $definitionA = json_decode(
            '{
              "collection": "App",
              "route": "app",
              "type": "object",
              "aggregate": {
                "$match": {
                  "created_year": {
                    "$gte": "PARSE_DATE(-4 years|Y)"
                  }
                },
                "$group": {
                  "_id": "app-count",
                  "count": {
                    "$sum": 1
                  }
                }
              },
              "schema": {}
            }
        '
        );

        $modelA = $mapper->map($definitionA, new AnalyticModel());
        $resultA = json_encode($buildPipeline->invokeArgs($analyticsManager, [$modelA]));
        $this->assertEquals($expect, $resultA);

        // Pipeline
        $definitionB = json_decode(
            '{
              "collection": "App",
              "route": "app",
              "type": "object",
              "pipeline": [
                {
                  "$match": {
                    "created_year": {
                      "$gte": "PARSE_DATE(-4 years|Y)"
                    }
                  }
                },
                {
                  "$group": {
                    "_id": "app-count",
                    "count": {
                      "$sum": 1
                    }
                  }
                }
              ],
              "schema": {}
            }
        '
        );

        $modelB = $mapper->map($definitionB, new AnalyticModel());

        $resultB = json_encode($buildPipeline->invokeArgs($analyticsManager, [$modelB]));
        $this->assertEquals($expect, $resultB);
    }
}