AbstractInterval::find() - Code Metrics - spiral-modules/statistics - Measure and Improve Code Quality continuously with Scrutinizer

AbstractInterval::find() A
last analyzed 2017-04-03 08:26 UTC

↳ Parent: AbstractInterval

Complexity

Conditions	2
Paths	2

Size

Total Lines	20
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	20
c	0
b	0
f	0
rs	9.4285
cc	2
eloc	15
nc	2
nop	5

<?php

namespace Spiral\Tests\Statistics\Extract\Intervals;

use Spiral\ORM\Entities\RecordSelector;
use Spiral\Statistics\Database\Event;
use Spiral\Statistics\Database\Occurrence;
use Spiral\Statistics\Database\Sources\OccurrenceSource;
use Spiral\Statistics\DatetimeConverter;
use Spiral\Statistics\Extract;
use Spiral\Statistics\Extract\Range;
use Spiral\Statistics\Track;
use Spiral\Tests\BaseTest;

abstract class AbstractInterval extends BaseTest
{
    const RANGE          = null;
    const RANGE_FIELD    = null;
    const RANGE_INTERVAL = null;
    const RANGE_FORMAT   = null;

    /** @var OccurrenceSource */
    protected $source;

    public function testRange()
    {
        $range = new Range(static::RANGE);
        $this->assertEquals(static::RANGE_FIELD, $range->getField());
        $this->assertEquals(new \DateInterval(static::RANGE_INTERVAL), $range->getInterval());
        $this->assertEquals(static::RANGE_FORMAT, $range->getFormat());
    }

    abstract protected function start(): \DateTime;

    abstract protected function end(): \DateTime;

    abstract protected function datetime1(): \DateTime;

    abstract protected function datetime2(): \DateTime;

    abstract protected function datetime3(): \DateTime;

    /**
     * Method shortcut.
     *
     * @param string             $periodField
     * @param \DateTimeInterface $periodValue
     * @param \DateTimeInterface $start
     * @param \DateTimeInterface $end
     * @param array              $events
     * @return RecordSelector
     */
    protected function find(
        string $periodField,
        \DateTimeInterface $periodValue,
        \DateTimeInterface $start,
        \DateTimeInterface $end,
        array $events = []
    ): RecordSelector
    {
        if (empty($this->source)) {
            $this->source =  $this->getSource();
        }

        return $this->source->findByGroupedInterval(
            $periodField,
            $periodValue,
            $start,
            $end,
            $events
        );
    }

    public function testSamePeriodOccurrenceSourceFindByGroupedInterval()
    {
        $converter = $this->getConverter();
        $track = $this->getTrack();

        $this->assertCount(0, $this->orm->source(Occurrence::class));
        $this->assertCount(0, $this->orm->source(Event::class));

        $start = $this->start();
        $end = $this->end();

        $datetime1 = $this->datetime1();
        $datetime2 = $this->datetime2();
        $period = $converter->convert($datetime1, static::RANGE);

        $this->assertCount(0, $this->orm->source(Occurrence::class));
        $this->assertCount(0, $this->orm->source(Event::class));
        $this->assertCount(0, $this->find(static::RANGE_FIELD, $period, $start, $end));

        $track->events(['event 1' => 1, 'event 2' => 2, 'event 3' => 3], $datetime1);
        $track->events(['event 3' => 3, 'event 4' => 4], $datetime2);

        $this->assertCount(2, $this->orm->source(Occurrence::class));
        $this->assertCount(5, $this->orm->source(Event::class));

        //Check if passed events make difference
        $this->dataTest($period, $start, $end, [
            [2, []],
            [1, ['event 1']],
            [1, ['event 1', 'event 2']],
            [2, ['event 1', 'event 3']],
            [2, ['event 1', 'event 2', 'event 3', 'event 4']],
            [1, ['event 4']],
            [0, ['event 5']],
        ]);

        //Check if passed time and events make difference
        $start1 = clone $datetime1;
        $start1->setTime(13, 0, 0);

        $end1 = clone $datetime1;
        $end1->setTime(13, 0, 0);

        $this->dataTest($period, $start1, $end, [
            [1, []],
            [0, ['event 1']],
            [0, ['event 1', 'event 2']],
            [1, ['event 1', 'event 3']],
            [1, ['event 1', 'event 2', 'event 3', 'event 4']],
            [1, ['event 4']],
            [0, ['event 5']],
        ]);

        //Check if passed end time and events make difference
        $this->dataTest($period, $start, $end1, [
            [1, []],
            [1, ['event 1']],
            [1, ['event 1', 'event 2']],
            [1, ['event 1', 'event 3']],
            [1, ['event 1', 'event 2', 'event 3', 'event 4']],
            [0, ['event 4']],
            [0, ['event 5']],
        ]);
    }

    public function testAnotherPeriodOccurrenceSourceFindByGroupedInterval()
    {
        $converter = $this->getConverter();
        $track = $this->getTrack();

        $this->assertCount(0, $this->orm->source(Occurrence::class));
        $this->assertCount(0, $this->orm->source(Event::class));

        $start = $this->start();
        $end = $this->end();

        $datetime1 = $this->datetime1();
        $datetime2 = $this->datetime3();
        $period1 = $converter->convert($datetime1, static::RANGE);
        $period2 = $converter->convert($datetime2, static::RANGE);

        $this->assertCount(0, $this->orm->source(Occurrence::class));
        $this->assertCount(0, $this->orm->source(Event::class));
        $this->assertCount(0, $this->find(static::RANGE_FIELD, $period1, $start, $end));

        $track->events(['event 1' => 1, 'event 2' => 2, 'event 3' => 3], $datetime1);
        $track->events(['event 3' => 3, 'event 4' => 4], $datetime2);

        $this->assertCount(2, $this->orm->source(Occurrence::class));
        $this->assertCount(5, $this->orm->source(Event::class));

        //Check if passed events make difference
        $this->dataTest($period1, $start, $end, [
            [1, []],
            [1, ['event 1']],
            [1, ['event 1', 'event 2']],
            [1, ['event 1', 'event 3']],
            [1, ['event 1', 'event 2', 'event 3', 'event 4']],
            [0, ['event 4']],
            [0, ['event 5']],
        ]);
        $this->dataTest($period2, $start, $end, [
            [1, []],
            [0, ['event 1']],
            [0, ['event 1', 'event 2']],
            [1, ['event 1', 'event 3']],
            [1, ['event 1', 'event 2', 'event 3', 'event 4']],
            [1, ['event 4']],
            [0, ['event 5']],
        ]);

        //Check if passed start time and events make difference
        $start1 = clone $datetime1;
        $start1->setTime(13, 0, 0);

        $end1 = clone $datetime1;
        $end1->setTime(13, 0, 0);

        $this->dataTest($period1, $start1, $end, [
            [0, []],
            [0, ['event 1']],
            [0, ['event 1', 'event 2']],
            [0, ['event 1', 'event 3']],
            [0, ['event 1', 'event 2', 'event 3', 'event 4']],
            [0, ['event 4']],
            [0, ['event 5']],
        ]);
        $this->dataTest($period2, $start1, $end, [
            [1, []],
            [0, ['event 1']],
            [0, ['event 1', 'event 2']],
            [1, ['event 1', 'event 3']],
            [1, ['event 1', 'event 2', 'event 3', 'event 4']],
            [1, ['event 4']],
            [0, ['event 5']],
        ]);

        //Check if passed end time and events make difference
        $this->dataTest($period1, $start, $end1, [
            [1, []],
            [1, ['event 1']],
            [1, ['event 1', 'event 2']],
            [1, ['event 1', 'event 3']],
            [1, ['event 1', 'event 2', 'event 3', 'event 4']],
            [0, ['event 4']],
            [0, ['event 5']],
        ]);
        $this->dataTest($period2, $start, $end1, [
            [0, []],
            [0, ['event 1']],
            [0, ['event 1', 'event 2']],
            [0, ['event 1', 'event 3']],
            [0, ['event 1', 'event 2', 'event 3', 'event 4']],
            [0, ['event 4']],
            [0, ['event 5']],
        ]);
    }

    protected function dataTest(
        \DateTimeInterface $period,
        \DateTimeInterface $start,
        \DateTimeInterface $end,
        array $data
    ) {
        $field = static::RANGE_FIELD;

        foreach ($data as $arr) {
            $this->assertCount($arr[0], $this->find($field, $period, $start, $end, $arr[1]));
        }
    }

//    public function testExtractEvents(){}

//    public function testExtract()
//    {
//        /** @var Extract $extract */
//        $extract = $this->container->get(Extract::class);
//        /** @var Track $track */
//        $track = $this->container->get(Track::class);
//
//        $datetime = new \DateTime('today noon');
//        $datetime2 = new \DateTime('today noon + 2 hours');
//
//        $this->assertCount(0, $this->orm->source(Occurrence::class));
//        $this->assertCount(0, $this->orm->source(Event::class));
//
//        $track->events([
//            'event1' => 1,
//            'event2' => 2
//        ], $datetime);
//
//        $track->events([
//            'event1' => 3,
//            'event2' => 4
//        ], $datetime2);
//
//        $this->assertCount(2, $this->orm->source(Occurrence::class));
//        $this->assertCount(4, $this->orm->source(Event::class));
//
//        //test start same date
//        $start = new \DateTime('today');
//        $end = new \DateTime('today + 7 days');
//        $range = new Extract\Range(static::RANGE);
//        $results = $extract->events(clone $start, clone $end, static::RANGE, ['event1', 'event2']);
//
//        $label = $start->format($range->getFormat());
//        $this->assertArrayHasKey($label, $results->results());
//        $this->assertArrayHasKey('event1', $results->results()[$label]);
//        $this->assertArrayHasKey('event2', $results->results()[$label]);
//        $this->assertEquals(4, $results->results()[$label]['event1']);
//        $this->assertEquals(6, $results->results()[$label]['event2']);
//
//        //test start end date
//        $start = new \DateTime('today - 7 days');
//        $end = new \DateTime('today');
//        $range = new Extract\Range(static::RANGE);
//        $results = $extract->events(clone $start, clone $end, static::RANGE, ['event1', 'event2']);
//
//        $label = $end->format($range->getFormat());
//        $this->assertArrayHasKey($label, $results->results());
//        $this->assertArrayHasKey('event1', $results->results()[$label]);
//        $this->assertArrayHasKey('event2', $results->results()[$label]);
//        $this->assertEquals(4, $results->results()[$label]['event1']);
//        $this->assertEquals(6, $results->results()[$label]['event2']);
//
//        //test same start and end date
//        $start = $end = new \DateTime('today');
//        $range = new Extract\Range(static::RANGE);
//        $results = $extract->events(clone $start, clone $end, static::RANGE, ['event1', 'event2']);
//
//        $label = $end->format($range->getFormat());
//        $this->assertArrayHasKey($label, $results->results());
//        $this->assertArrayHasKey('event1', $results->results()[$label]);
//        $this->assertArrayHasKey('event2', $results->results()[$label]);
//        $this->assertEquals(4, $results->results()[$label]['event1']);
//        $this->assertEquals(6, $results->results()[$label]['event2']);
//    }
}

1			<?php
2
3			namespace Spiral\Tests\Statistics\Extract\Intervals;
4
5			use Spiral\ORM\Entities\RecordSelector;
6			use Spiral\Statistics\Database\Event;
7			use Spiral\Statistics\Database\Occurrence;
8			use Spiral\Statistics\Database\Sources\OccurrenceSource;
9			use Spiral\Statistics\DatetimeConverter;
10			use Spiral\Statistics\Extract;
11			use Spiral\Statistics\Extract\Range;
12			use Spiral\Statistics\Track;
13			use Spiral\Tests\BaseTest;
14
15			abstract class AbstractInterval extends BaseTest
16			{
17			const RANGE = null;
18			const RANGE_FIELD = null;
19			const RANGE_INTERVAL = null;
20			const RANGE_FORMAT = null;
21
22			/** @var OccurrenceSource */
23			protected $source;
24
25			public function testRange()
26			{
27			$range = new Range(static::RANGE);
28			$this->assertEquals(static::RANGE_FIELD, $range->getField());
29			$this->assertEquals(new \DateInterval(static::RANGE_INTERVAL), $range->getInterval());
30			$this->assertEquals(static::RANGE_FORMAT, $range->getFormat());
31			}
32
33			abstract protected function start(): \DateTime;
34
35			abstract protected function end(): \DateTime;
36
37			abstract protected function datetime1(): \DateTime;
38
39			abstract protected function datetime2(): \DateTime;
40
41			abstract protected function datetime3(): \DateTime;
42
43			/**
44			* Method shortcut.
45			*
46			* @param string $periodField
47			* @param \DateTimeInterface $periodValue
48			* @param \DateTimeInterface $start
49			* @param \DateTimeInterface $end
50			* @param array $events
51			* @return RecordSelector
52			*/
53			protected function find(
54			string $periodField,
55			\DateTimeInterface $periodValue,
56			\DateTimeInterface $start,
57			\DateTimeInterface $end,
58			array $events = []
59			): RecordSelector
60			{
61			if (empty($this->source)) {
62			$this->source = $this->getSource();
63			}
64
65			return $this->source->findByGroupedInterval(
66			$periodField,
67			$periodValue,
68			$start,
69			$end,
70			$events
71			);
72			}
73
74			public function testSamePeriodOccurrenceSourceFindByGroupedInterval()
75			{
76			$converter = $this->getConverter();
77			$track = $this->getTrack();
78
79			$this->assertCount(0, $this->orm->source(Occurrence::class));
80			$this->assertCount(0, $this->orm->source(Event::class));
81
82			$start = $this->start();
83			$end = $this->end();
84
85			$datetime1 = $this->datetime1();
86			$datetime2 = $this->datetime2();
87			$period = $converter->convert($datetime1, static::RANGE);
88
89			$this->assertCount(0, $this->orm->source(Occurrence::class));
90			$this->assertCount(0, $this->orm->source(Event::class));
91			$this->assertCount(0, $this->find(static::RANGE_FIELD, $period, $start, $end));
92
93			$track->events(['event 1' => 1, 'event 2' => 2, 'event 3' => 3], $datetime1);
94			$track->events(['event 3' => 3, 'event 4' => 4], $datetime2);
95
96			$this->assertCount(2, $this->orm->source(Occurrence::class));
97			$this->assertCount(5, $this->orm->source(Event::class));
98
99			//Check if passed events make difference
100			$this->dataTest($period, $start, $end, [
101			[2, []],
102			[1, ['event 1']],
103			[1, ['event 1', 'event 2']],
104			[2, ['event 1', 'event 3']],
105			[2, ['event 1', 'event 2', 'event 3', 'event 4']],
106			[1, ['event 4']],
107			[0, ['event 5']],
108			]);
109
110			//Check if passed time and events make difference
111			$start1 = clone $datetime1;
112			$start1->setTime(13, 0, 0);
113
114			$end1 = clone $datetime1;
115			$end1->setTime(13, 0, 0);
116
117			$this->dataTest($period, $start1, $end, [
118			[1, []],
119			[0, ['event 1']],
120			[0, ['event 1', 'event 2']],
121			[1, ['event 1', 'event 3']],
122			[1, ['event 1', 'event 2', 'event 3', 'event 4']],
123			[1, ['event 4']],
124			[0, ['event 5']],
125			]);
126
127			//Check if passed end time and events make difference
128			$this->dataTest($period, $start, $end1, [
129			[1, []],
130			[1, ['event 1']],
131			[1, ['event 1', 'event 2']],
132			[1, ['event 1', 'event 3']],
133			[1, ['event 1', 'event 2', 'event 3', 'event 4']],
134			[0, ['event 4']],
135			[0, ['event 5']],
136			]);
137			}
138
139			public function testAnotherPeriodOccurrenceSourceFindByGroupedInterval()
140			{
141			$converter = $this->getConverter();
142			$track = $this->getTrack();
143
144			$this->assertCount(0, $this->orm->source(Occurrence::class));
145			$this->assertCount(0, $this->orm->source(Event::class));
146
147			$start = $this->start();
148			$end = $this->end();
149
150			$datetime1 = $this->datetime1();
151			$datetime2 = $this->datetime3();
152			$period1 = $converter->convert($datetime1, static::RANGE);
153			$period2 = $converter->convert($datetime2, static::RANGE);
154
155			$this->assertCount(0, $this->orm->source(Occurrence::class));
156			$this->assertCount(0, $this->orm->source(Event::class));
157			$this->assertCount(0, $this->find(static::RANGE_FIELD, $period1, $start, $end));
158
159			$track->events(['event 1' => 1, 'event 2' => 2, 'event 3' => 3], $datetime1);
160			$track->events(['event 3' => 3, 'event 4' => 4], $datetime2);
161
162			$this->assertCount(2, $this->orm->source(Occurrence::class));
163			$this->assertCount(5, $this->orm->source(Event::class));
164
165			//Check if passed events make difference
166			$this->dataTest($period1, $start, $end, [
167			[1, []],
168			[1, ['event 1']],
169			[1, ['event 1', 'event 2']],
170			[1, ['event 1', 'event 3']],
171			[1, ['event 1', 'event 2', 'event 3', 'event 4']],
172			[0, ['event 4']],
173			[0, ['event 5']],
174			]);
175			$this->dataTest($period2, $start, $end, [
176			[1, []],
177			[0, ['event 1']],
178			[0, ['event 1', 'event 2']],
179			[1, ['event 1', 'event 3']],
180			[1, ['event 1', 'event 2', 'event 3', 'event 4']],
181			[1, ['event 4']],
182			[0, ['event 5']],
183			]);
184
185			//Check if passed start time and events make difference
186			$start1 = clone $datetime1;
187			$start1->setTime(13, 0, 0);
188
189			$end1 = clone $datetime1;
190			$end1->setTime(13, 0, 0);
191
192			$this->dataTest($period1, $start1, $end, [
193			[0, []],
194			[0, ['event 1']],
195			[0, ['event 1', 'event 2']],
196			[0, ['event 1', 'event 3']],
197			[0, ['event 1', 'event 2', 'event 3', 'event 4']],
198			[0, ['event 4']],
199			[0, ['event 5']],
200			]);
201			$this->dataTest($period2, $start1, $end, [
202			[1, []],
203			[0, ['event 1']],
204			[0, ['event 1', 'event 2']],
205			[1, ['event 1', 'event 3']],
206			[1, ['event 1', 'event 2', 'event 3', 'event 4']],
207			[1, ['event 4']],
208			[0, ['event 5']],
209			]);
210
211			//Check if passed end time and events make difference
212			$this->dataTest($period1, $start, $end1, [
213			[1, []],
214			[1, ['event 1']],
215			[1, ['event 1', 'event 2']],
216			[1, ['event 1', 'event 3']],
217			[1, ['event 1', 'event 2', 'event 3', 'event 4']],
218			[0, ['event 4']],
219			[0, ['event 5']],
220			]);
221			$this->dataTest($period2, $start, $end1, [
222			[0, []],
223			[0, ['event 1']],
224			[0, ['event 1', 'event 2']],
225			[0, ['event 1', 'event 3']],
226			[0, ['event 1', 'event 2', 'event 3', 'event 4']],
227			[0, ['event 4']],
228			[0, ['event 5']],
229			]);
230			}
231
232			protected function dataTest(
233			\DateTimeInterface $period,
234			\DateTimeInterface $start,
235			\DateTimeInterface $end,
236			array $data
237			) {
238			$field = static::RANGE_FIELD;
239
240			foreach ($data as $arr) {
241			$this->assertCount($arr[0], $this->find($field, $period, $start, $end, $arr[1]));
242			}
243			}
244
245			// public function testExtractEvents(){}
246
247			// public function testExtract()
248			// {
249			// /** @var Extract $extract */
250			// $extract = $this->container->get(Extract::class);
251			// /** @var Track $track */
252			// $track = $this->container->get(Track::class);
253			//
254			// $datetime = new \DateTime('today noon');
255			// $datetime2 = new \DateTime('today noon + 2 hours');
256			//
257			// $this->assertCount(0, $this->orm->source(Occurrence::class));
258			// $this->assertCount(0, $this->orm->source(Event::class));
259			//
260			// $track->events([
261			// 'event1' => 1,
262			// 'event2' => 2
263			// ], $datetime);
264			//
265			// $track->events([
266			// 'event1' => 3,
267			// 'event2' => 4
268			// ], $datetime2);
269			//
270			// $this->assertCount(2, $this->orm->source(Occurrence::class));
271			// $this->assertCount(4, $this->orm->source(Event::class));
272			//
273			// //test start same date
274			// $start = new \DateTime('today');
275			// $end = new \DateTime('today + 7 days');
276			// $range = new Extract\Range(static::RANGE);
277			// $results = $extract->events(clone $start, clone $end, static::RANGE, ['event1', 'event2']);
278			//
279			// $label = $start->format($range->getFormat());
280			// $this->assertArrayHasKey($label, $results->results());
281			// $this->assertArrayHasKey('event1', $results->results()[$label]);
282			// $this->assertArrayHasKey('event2', $results->results()[$label]);
283			// $this->assertEquals(4, $results->results()[$label]['event1']);
284			// $this->assertEquals(6, $results->results()[$label]['event2']);
285			//
286			// //test start end date
287			// $start = new \DateTime('today - 7 days');
288			// $end = new \DateTime('today');
289			// $range = new Extract\Range(static::RANGE);
290			// $results = $extract->events(clone $start, clone $end, static::RANGE, ['event1', 'event2']);
291			//
292			// $label = $end->format($range->getFormat());
293			// $this->assertArrayHasKey($label, $results->results());
294			// $this->assertArrayHasKey('event1', $results->results()[$label]);
295			// $this->assertArrayHasKey('event2', $results->results()[$label]);
296			// $this->assertEquals(4, $results->results()[$label]['event1']);
297			// $this->assertEquals(6, $results->results()[$label]['event2']);
298			//
299			// //test same start and end date
300			// $start = $end = new \DateTime('today');
301			// $range = new Extract\Range(static::RANGE);
302			// $results = $extract->events(clone $start, clone $end, static::RANGE, ['event1', 'event2']);
303			//
304			// $label = $end->format($range->getFormat());
305			// $this->assertArrayHasKey($label, $results->results());
306			// $this->assertArrayHasKey('event1', $results->results()[$label]);
307			// $this->assertArrayHasKey('event2', $results->results()[$label]);
308			// $this->assertEquals(4, $results->results()[$label]['event1']);
309			// $this->assertEquals(6, $results->results()[$label]['event2']);
310			// }
311			}

spiral-modules / statistics

AbstractInterval::find() A last analyzed 2017-04-03 08:26 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

AbstractInterval::find() A
last analyzed 2017-04-03 08:26 UTC