TransportBenchmarkTest::_checkTransport() - Code Metrics - Inspection of "Remove some functional test skip conditions" - ruflin/Elastica - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1936)

by François-Xavier

created 2021-03-19 13:32 UTC

TransportBenchmarkTest::_checkTransport() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
c	0
b	0
f	0
rs	10
cc	1
nc	1
nop	2

<?php

namespace Elastica\Test\Transport;

use Elastica\Document;
use Elastica\Index;
use Elastica\Mapping;
use Elastica\Query;
use Elastica\Query\MatchAll;
use Elastica\Query\Term;
use Elastica\Request;
use Elastica\Test\Base as BaseTest;

/**
 * @group benchmark
 *
 * @internal
 */
class TransportBenchmarkTest extends BaseTest
{
    protected $_max = 1000;
    protected $_maxData = 20;
    protected static $_results = [];

    public static function tearDownAfterClass(): void
    {
        self::printResults();
    }

    protected function setUp(): void
    {
        parent::setUp();
        $this->markTestSkipped('Benchmarks currently skipped: it has to be reworked');
    }

    /**
     * @dataProvider providerTransport
     */
    public function testAddDocument(array $config, string $transport): void
    {
        $index = $this->getIndex($config);
        $index->create([], [
            'recreate' => true,
        ]);

        $times = [];
        for ($i = 0; $i < $this->_max; ++$i) {
            $data = $this->getData($i);
            $doc = new Document($i, $data);
            $result = $index->addDocument($doc);
            $times[] = $result->getQueryTime();
            $this->assertTrue($result->isOk());
        }

        $index->refresh();

        self::logResults('insert', $transport, $times);
    }

    /**
     * @depends testAddDocument
     * @dataProvider providerTransport
     *
     * @param mixed $transport
     */
    public function testRandomRead(array $config, $transport): void
    {
        $index = $this->getIndex($config);
        $index->search('test');

        $times = [];
        for ($i = 0; $i < $this->_max; ++$i) {
            $test = \mt_rand(1, $this->_max);
            $query = new Query();
            $query->setQuery(new MatchAll());
            $query->setPostFilter(new Term(['test' => $test]));
            $result = $index->search($query);
            $times[] = $result->getResponse()->getQueryTime();
        }

        self::logResults('random read', $transport, $times);
    }

    /**
     * @depends testAddDocument
     * @dataProvider providerTransport
     *
     * @param mixed $transport
     */
    public function testBulk(array $config, $transport): void
    {
        $index = $this->getIndex($config);

        $times = [];
        for ($i = 0; $i < $this->_max; ++$i) {
            $docs = [];
            for ($j = 0; $j < 10; ++$j) {
                $data = $this->getData($i.$j);
                $docs[] = new Document($i, $data);
            }

            $result = $index->addDocuments($docs);
            $times[] = $result->getQueryTime();
        }

        self::logResults('bulk', $transport, $times);
    }

    /**
     * @dataProvider providerTransport
     */
    public function testGetMapping(array $config, string $transport): void
    {
        $client = $this->_getClient($config);
        $index = $client->getIndex('benchmark');
        $index->create([], [
            'recreate' => true,
        ]);

        // Define mapping
        $mapping = new Mapping();
        $mapping->setParam('_boost', ['name' => '_boost', 'null_value' => 1.0]);
        $mapping->setProperties([
            'id' => ['type' => 'integer'],
            'user' => [
                'type' => 'object',
                'properties' => [
                    'name' => ['type' => 'text', 'copy_to' => 'allincluded'],
                    'fullName' => ['type' => 'text', 'copy_to' => 'allincluded'],
                ],
            ],
            'msg' => ['type' => 'text', 'copy_to' => 'allincluded'],
            'tstamp' => ['type' => 'date'],
            'location' => ['type' => 'geo_point'],
            '_boost' => ['type' => 'float'],
            'allincluded' => ['type' => 'text'],
        ]);

        $index->setMapping($mapping);
        $index->refresh();

        $times = [];
        for ($i = 0; $i < $this->_max; ++$i) {
            $response = $index->request('_mapping', Request::GET);
            $times[] = $response->getQueryTime();
        }
        self::logResults('get mapping', $transport, $times);
    }

    public function providerTransport(): iterable
    {
        yield [[
            'transport' => 'Http',
            'host' => $this->_getHost(),
            'port' => $this->_getPort(),
            'persistent' => false,
        ],
            'Http:NotPersistent',
        ];
        yield [[
            'transport' => 'Http',
            'host' => $this->_getHost(),
            'port' => $this->_getPort(),
            'persistent' => true,
        ],
            'Http:Persistent',
        ];
    }

    protected function getIndex(array $config): Index
    {
        $client = $this->_getClient($config);
        $index = $client->getIndex('benchmark'.self::buildUniqueId());
        $index->create(['index' => ['number_of_shards' => 1, 'number_of_replicas' => 0]], true);

        return $index;
    }

    protected function getData(string $test): array
    {
        $data = [
            'test' => $test,
            'name' => [],
        ];
        for ($i = 0; $i < $this->_maxData; ++$i) {
            $data['name'][] = self::buildUniqueId();
        }

        return $data;
    }

    protected static function logResults(string $name, string $transport, array $times): void
    {
        self::$_results[$name][$transport] = [
            'count' => \count($times),
            'max' => \max($times) * 1000,
            'min' => \min($times) * 1000,
            'mean' => (\array_sum($times) / \count($times)) * 1000,
        ];
    }

    protected static function printResults(): void
    {
        if (!\count(self::$_results)) {
            return;
        }

        echo \sprintf(
            "\n%-12s | %-20s | %-12s | %-12s | %-12s | %-12s\n\n",
            'NAME',
            'TRANSPORT',
            'COUNT',
            'MAX',
            'MIN',
            'MEAN'
        );
        foreach (self::$_results as $name => $values) {
            $means = [];
            foreach ($values as $times) {
                $means[] = $times['mean'];
            }
            $minMean = \min($means);
            foreach ($values as $transport => $times) {
                $perc = 0;

                if (0 !== $minMean) {
                    $perc = (($times['mean'] - $minMean) / $minMean) * 100;
                }

                echo \sprintf(
                    "%-12s | %-20s | %-12d | %-12.2f | %-12.2f | %-12.2f | %+03.2f\n",
                    $name,
                    $transport,
                    $times['count'],
                    $times['max'],
                    $times['min'],
                    $times['mean'],
                    $perc
                );
            }
            echo "\n";
        }
    }
}


1			<?php
2
3			namespace Elastica\Test\Transport;
4
5			use Elastica\Document;
6			use Elastica\Index;
7			use Elastica\Mapping;
8			use Elastica\Query;
9			use Elastica\Query\MatchAll;
10			use Elastica\Query\Term;
11			use Elastica\Request;
12			use Elastica\Test\Base as BaseTest;
13
14			/**
15			* @group benchmark
16			*
17			* @internal
18			*/
19			class TransportBenchmarkTest extends BaseTest
20			{
21			protected $_max = 1000;
22			protected $_maxData = 20;
23			protected static $_results = [];
24
25			public static function tearDownAfterClass(): void
26			{
27			self::printResults();
28			}
29
30			protected function setUp(): void
31			{
32			parent::setUp();
33			$this->markTestSkipped('Benchmarks currently skipped: it has to be reworked');
34			}
35
36			/**
37			* @dataProvider providerTransport
38			*/
39			public function testAddDocument(array $config, string $transport): void
40			{
41			$index = $this->getIndex($config);
42			$index->create([], [
43			'recreate' => true,
44			]);
45
46			$times = [];
47			for ($i = 0; $i < $this->_max; ++$i) {
48			$data = $this->getData($i);
49			$doc = new Document($i, $data);
50			$result = $index->addDocument($doc);
51			$times[] = $result->getQueryTime();
52			$this->assertTrue($result->isOk());
53			}
54
55			$index->refresh();
56
57			self::logResults('insert', $transport, $times);
58			}
59
60			/**
61			* @depends testAddDocument
62			* @dataProvider providerTransport
63			*
64			* @param mixed $transport
65			*/
66			public function testRandomRead(array $config, $transport): void
67			{
68			$index = $this->getIndex($config);
69			$index->search('test');
70
71			$times = [];
72			for ($i = 0; $i < $this->_max; ++$i) {
73			$test = \mt_rand(1, $this->_max);
74			$query = new Query();
75			$query->setQuery(new MatchAll());
76			$query->setPostFilter(new Term(['test' => $test]));
77			$result = $index->search($query);
78			$times[] = $result->getResponse()->getQueryTime();
79			}
80
81			self::logResults('random read', $transport, $times);
82			}
83
84			/**
85			* @depends testAddDocument
86			* @dataProvider providerTransport
87			*
88			* @param mixed $transport
89			*/
90			public function testBulk(array $config, $transport): void
91			{
92			$index = $this->getIndex($config);
93
94			$times = [];
95			for ($i = 0; $i < $this->_max; ++$i) {
96			$docs = [];
97			for ($j = 0; $j < 10; ++$j) {
98			$data = $this->getData($i.$j);
99			$docs[] = new Document($i, $data);
100			}
101
102			$result = $index->addDocuments($docs);
103			$times[] = $result->getQueryTime();
104			}
105
106			self::logResults('bulk', $transport, $times);
107			}
108
109			/**
110			* @dataProvider providerTransport
111			*/
112			public function testGetMapping(array $config, string $transport): void
113			{
114			$client = $this->_getClient($config);
115			$index = $client->getIndex('benchmark');
116			$index->create([], [
117			'recreate' => true,
118			]);
119
120			// Define mapping
121			$mapping = new Mapping();
122			$mapping->setParam('_boost', ['name' => '_boost', 'null_value' => 1.0]);
123			$mapping->setProperties([
124			'id' => ['type' => 'integer'],
125			'user' => [
126			'type' => 'object',
127			'properties' => [
128			'name' => ['type' => 'text', 'copy_to' => 'allincluded'],
129			'fullName' => ['type' => 'text', 'copy_to' => 'allincluded'],
130			],
131			],
132			'msg' => ['type' => 'text', 'copy_to' => 'allincluded'],
133			'tstamp' => ['type' => 'date'],
134			'location' => ['type' => 'geo_point'],
135			'_boost' => ['type' => 'float'],
136			'allincluded' => ['type' => 'text'],
137			]);
138
139			$index->setMapping($mapping);
140			$index->refresh();
141
142			$times = [];
143			for ($i = 0; $i < $this->_max; ++$i) {
144			$response = $index->request('_mapping', Request::GET);
145			$times[] = $response->getQueryTime();
146			}
147			self::logResults('get mapping', $transport, $times);
148			}
149
150			public function providerTransport(): iterable
151			{
152			yield [[
153			'transport' => 'Http',
154			'host' => $this->_getHost(),
155			'port' => $this->_getPort(),
156			'persistent' => false,
157			],
158			'Http:NotPersistent',
159			];
160			yield [[
161			'transport' => 'Http',
162			'host' => $this->_getHost(),
163			'port' => $this->_getPort(),
164			'persistent' => true,
165			],
166			'Http:Persistent',
167			];
168			}
169
170			protected function getIndex(array $config): Index
171			{
172			$client = $this->_getClient($config);
173			$index = $client->getIndex('benchmark'.self::buildUniqueId());
174			$index->create(['index' => ['number_of_shards' => 1, 'number_of_replicas' => 0]], true);
175
176			return $index;
177			}
178
179			protected function getData(string $test): array
180			{
181			$data = [
182			'test' => $test,
183			'name' => [],
184			];
185			for ($i = 0; $i < $this->_maxData; ++$i) {
186			$data['name'][] = self::buildUniqueId();
187			}
188
189			return $data;
190			}
191
192			protected static function logResults(string $name, string $transport, array $times): void
193			{
194			self::$_results[$name][$transport] = [
195			'count' => \count($times),
196			'max' => \max($times) * 1000,
197			'min' => \min($times) * 1000,
198			'mean' => (\array_sum($times) / \count($times)) * 1000,
199			];
200			}
201
202			protected static function printResults(): void
203			{
204			if (!\count(self::$_results)) {
205			return;
206			}
207
208			echo \sprintf(
209			"\n%-12s \| %-20s \| %-12s \| %-12s \| %-12s \| %-12s\n\n",
210			'NAME',
211			'TRANSPORT',
212			'COUNT',
213			'MAX',
214			'MIN',
215			'MEAN'
216			);
217			foreach (self::$_results as $name => $values) {
218			$means = [];
219			foreach ($values as $times) {
220			$means[] = $times['mean'];
221			}
222			$minMean = \min($means);
223			foreach ($values as $transport => $times) {
224			$perc = 0;
225
226			if (0 !== $minMean) {
227			$perc = (($times['mean'] - $minMean) / $minMean) * 100;
228			}
229
230			echo \sprintf(
231			"%-12s \| %-20s \| %-12d \| %-12.2f \| %-12.2f \| %-12.2f \| %+03.2f\n",
232			$name,
233			$transport,
234			$times['count'],
235			$times['max'],
236			$times['min'],
237			$times['mean'],
238			$perc
239			);
240			}
241			echo "\n";
242			}
243			}
244			}
245

ruflin / Elastica

Pull Request — master (#1936)

TransportBenchmarkTest::_checkTransport() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like