Connect - Code Metrics - Inspection of "kw_connect - update dependencies and test environm..." - alex-kalanis/kw_connect - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 9ccabb...39bdf1 )

by Petr

created 2023-05-16 01:04 UTC

Connect A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	33
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	9
c	1
b	0
f	0
dl	0
loc	33
rs	10
wmc	6

<?php

namespace ArraysTests;


use CommonTestClass;
use kalanis\kw_connect\arrays;
use kalanis\kw_connect\core\AConnector;
use kalanis\kw_connect\core\ConnectException;
use kalanis\kw_connect\core\Interfaces\IRow;


class FiltersTest extends CommonTestClass
{
    /**
     * @throws ConnectException
     */
    public function testFailSource()
    {
        $filter = new arrays\Filters\Exact();
        $this->expectException(ConnectException::class);
        $filter->setDataSource(null);
    }

    /**
     * @throws ConnectException
     */
    public function testExact()
    {
        $filter = new arrays\Filters\Exact();
        $filter->setDataSource($this->getDataSource());
        $filter->setFiltering('mno', true);
        $this->assertEquals(4, count($filter->getDataSource()));
    }

    /**
     * @throws ConnectException
     */
    public function testContains()
    {
        $filter = new arrays\Filters\Contains();
        $filter->setDataSource($this->getDataSource());
        $filter->setFiltering('def', 'a');
        $this->assertEquals(4, count($filter->getDataSource()));
    }

    /**
     * @throws ConnectException
     */
    public function testFrom()
    {
        $filter = new arrays\Filters\From();
        $filter->setDataSource($this->getDataSource());
        $filter->setFiltering('jkl', 456);
        $this->assertEquals(2, count($filter->getDataSource()));
    }

    /**
     * @throws ConnectException
     */
    public function testFromWith()
    {
        $filter = new arrays\Filters\FromWith();
        $filter->setDataSource($this->getDataSource());
        $filter->setFiltering('jkl', 456);
        $this->assertEquals(3, count($filter->getDataSource()));
    }

    /**
     * @throws ConnectException
     */
    public function testTo()
    {
        $filter = new arrays\Filters\To();
        $filter->setDataSource($this->getDataSource());
        $filter->setFiltering('jkl', 456);
        $this->assertEquals(6, count($filter->getDataSource()));
    }

    /**
     * @throws ConnectException
     */
    public function testToWith()
    {
        $filter = new arrays\Filters\ToWith();
        $filter->setDataSource($this->getDataSource());
        $filter->setFiltering('jkl', 456);
        $this->assertEquals(7, count($filter->getDataSource()));
    }

    /**
     * @throws ConnectException
     */
    public function testRangeOk()
    {
        $filter = new arrays\Filters\Range();
        $filter->setDataSource($this->getDataSource());
        $filter->setFiltering('jkl', [345, 678]);
        $this->assertEquals(2, count($filter->getDataSource()));
    }

    /**
     * @throws ConnectException
     */
    public function testRangeFail()
    {
        $filter = new arrays\Filters\Range();
        $filter->setDataSource($this->getDataSource());
        $this->expectException(ConnectException::class);
        $filter->setFiltering('jkl', 456);
        $this->expectException(ConnectException::class);
        $filter->setFiltering('jkl', null);
        $this->expectException(ConnectException::class);
        $filter->setFiltering('jkl', 'ijn');
        $this->expectException(ConnectException::class);
        $filter->setFiltering('jkl', [456]);
        $this->expectException(ConnectException::class);
        $filter->setFiltering('jkl', [1=>789]);
    }

    /**
     * @throws ConnectException
     */
    public function testMultiple1()
    {
        $filter = new arrays\Filters\Multiple();
        $filter->addFilterFactory(arrays\Filters\Factory::getInstance());
        $filter->setDataSource($this->getDataSource());

        $filter->setFiltering('def', [
            // filter type => expected value; everything over column defined previously
            [arrays\Filters\Factory::ACTION_CONTAINS, 'e'],
            [arrays\Filters\Factory::ACTION_CONTAINS, 'a'],
        ]);
        $this->assertEquals(3, count($filter->getDataSource()));
    }

    /**
     * @throws ConnectException
     */
    public function testMultiple2()
    {
        $filter = new arrays\Filters\Multiple();
        $filter->addFilterFactory(arrays\Filters\Factory::getInstance());
        $filter->setDataSource($this->getDataSource());

        $filter->setFiltering('def', [
            // filter type => expected value; everything over column defined previously
            [
                arrays\Filters\Factory::ACTION_MULTIPLE, [
                    [arrays\Filters\Factory::ACTION_CONTAINS, 'a'],
                ]
            ],
            [arrays\Filters\Factory::ACTION_CONTAINS, 'e'],
        ]);
        $this->assertEquals(3, count($filter->getDataSource()));
    }

    protected function getDataSource(): arrays\FilteringArrays
    {
        $connect = new Connect($this->sourceRows());
        $connect->fetchData();
        return new arrays\FilteringArrays($connect->getTranslatedData());
    }
}


class Connect extends AConnector
{
    /** @var array */
    protected $dataSource = [];

    public function __construct(array $source)
    {
        $this->dataSource = $source;
    }

    protected function getFiltered(&$data)
    {
        return new arrays\FilteringArrays($data);
    }

    public function getTranslated($data): IRow
    {
        return new arrays\Row($data);
    }

    public function fetchData(): void
    {
        $this->parseData();
    }

    protected function parseData(): void
    {
        $this->translatedData = array_map([$this, 'getTranslated'], $this->dataSource);
    }

    public function &getTranslatedData(): array
    {
        return $this->translatedData;
    }
}


1			<?php
2
3			namespace ArraysTests;
4
5
6			use CommonTestClass;
7			use kalanis\kw_connect\arrays;
8			use kalanis\kw_connect\core\AConnector;
9			use kalanis\kw_connect\core\ConnectException;
10			use kalanis\kw_connect\core\Interfaces\IRow;
11
12
13			class FiltersTest extends CommonTestClass
14			{
15			/**
16			* @throws ConnectException
17			*/
18			public function testFailSource()
19			{
20			$filter = new arrays\Filters\Exact();
21			$this->expectException(ConnectException::class);
22			$filter->setDataSource(null);
23			}
24
25			/**
26			* @throws ConnectException
27			*/
28			public function testExact()
29			{
30			$filter = new arrays\Filters\Exact();
31			$filter->setDataSource($this->getDataSource());
32			$filter->setFiltering('mno', true);
33			$this->assertEquals(4, count($filter->getDataSource()));
34			}
35
36			/**
37			* @throws ConnectException
38			*/
39			public function testContains()
40			{
41			$filter = new arrays\Filters\Contains();
42			$filter->setDataSource($this->getDataSource());
43			$filter->setFiltering('def', 'a');
44			$this->assertEquals(4, count($filter->getDataSource()));
45			}
46
47			/**
48			* @throws ConnectException
49			*/
50			public function testFrom()
51			{
52			$filter = new arrays\Filters\From();
53			$filter->setDataSource($this->getDataSource());
54			$filter->setFiltering('jkl', 456);
55			$this->assertEquals(2, count($filter->getDataSource()));
56			}
57
58			/**
59			* @throws ConnectException
60			*/
61			public function testFromWith()
62			{
63			$filter = new arrays\Filters\FromWith();
64			$filter->setDataSource($this->getDataSource());
65			$filter->setFiltering('jkl', 456);
66			$this->assertEquals(3, count($filter->getDataSource()));
67			}
68
69			/**
70			* @throws ConnectException
71			*/
72			public function testTo()
73			{
74			$filter = new arrays\Filters\To();
75			$filter->setDataSource($this->getDataSource());
76			$filter->setFiltering('jkl', 456);
77			$this->assertEquals(6, count($filter->getDataSource()));
78			}
79
80			/**
81			* @throws ConnectException
82			*/
83			public function testToWith()
84			{
85			$filter = new arrays\Filters\ToWith();
86			$filter->setDataSource($this->getDataSource());
87			$filter->setFiltering('jkl', 456);
88			$this->assertEquals(7, count($filter->getDataSource()));
89			}
90
91			/**
92			* @throws ConnectException
93			*/
94			public function testRangeOk()
95			{
96			$filter = new arrays\Filters\Range();
97			$filter->setDataSource($this->getDataSource());
98			$filter->setFiltering('jkl', [345, 678]);
99			$this->assertEquals(2, count($filter->getDataSource()));
100			}
101
102			/**
103			* @throws ConnectException
104			*/
105			public function testRangeFail()
106			{
107			$filter = new arrays\Filters\Range();
108			$filter->setDataSource($this->getDataSource());
109			$this->expectException(ConnectException::class);
110			$filter->setFiltering('jkl', 456);
111			$this->expectException(ConnectException::class);
112			$filter->setFiltering('jkl', null);
113			$this->expectException(ConnectException::class);
114			$filter->setFiltering('jkl', 'ijn');
115			$this->expectException(ConnectException::class);
116			$filter->setFiltering('jkl', [456]);
117			$this->expectException(ConnectException::class);
118			$filter->setFiltering('jkl', [1=>789]);
119			}
120
121			/**
122			* @throws ConnectException
123			*/
124			public function testMultiple1()
125			{
126			$filter = new arrays\Filters\Multiple();
127			$filter->addFilterFactory(arrays\Filters\Factory::getInstance());
128			$filter->setDataSource($this->getDataSource());
129
130			$filter->setFiltering('def', [
131			// filter type => expected value; everything over column defined previously
132			[arrays\Filters\Factory::ACTION_CONTAINS, 'e'],
133			[arrays\Filters\Factory::ACTION_CONTAINS, 'a'],
134			]);
135			$this->assertEquals(3, count($filter->getDataSource()));
136			}
137
138			/**
139			* @throws ConnectException
140			*/
141			public function testMultiple2()
142			{
143			$filter = new arrays\Filters\Multiple();
144			$filter->addFilterFactory(arrays\Filters\Factory::getInstance());
145			$filter->setDataSource($this->getDataSource());
146
147			$filter->setFiltering('def', [
148			// filter type => expected value; everything over column defined previously
149			[
150			arrays\Filters\Factory::ACTION_MULTIPLE, [
151			[arrays\Filters\Factory::ACTION_CONTAINS, 'a'],
152			]
153			],
154			[arrays\Filters\Factory::ACTION_CONTAINS, 'e'],
155			]);
156			$this->assertEquals(3, count($filter->getDataSource()));
157			}
158
159			protected function getDataSource(): arrays\FilteringArrays
160			{
161			$connect = new Connect($this->sourceRows());
162			$connect->fetchData();
163			return new arrays\FilteringArrays($connect->getTranslatedData());
164			}
165			}
166
167
168			class Connect extends AConnector
169			{
170			/** @var array */
171			protected $dataSource = [];
172
173			public function __construct(array $source)
174			{
175			$this->dataSource = $source;
176			}
177
178			protected function getFiltered(&$data)
179			{
180			return new arrays\FilteringArrays($data);
181			}
182
183			public function getTranslated($data): IRow
184			{
185			return new arrays\Row($data);
186			}
187
188			public function fetchData(): void
189			{
190			$this->parseData();
191			}
192
193			protected function parseData(): void
194			{
195			$this->translatedData = array_map([$this, 'getTranslated'], $this->dataSource);
196			}
197
198			public function &getTranslatedData(): array
199			{
200			return $this->translatedData;
201			}
202			}
203

alex-kalanis / kw_connect

Push — master ( 9ccabb...39bdf1 )

Connect A

Complexity

Size/Duplication

Importance

Duplication Side-by-Side

Filter issues like