feat(search): split range queries with multiple ranges to a union of ranges

Author: Mikolaj Misiurewicz

Tests/Context/ContextFilterFactoryTest.php

@@ -0,0 +1,99 @@
+<?php
+declare(strict_types=1);
+
+namespace Context;
+
+use Markup\NeedleBundle\Attribute\AttributeProviderInterface;
+use Markup\NeedleBundle\Attribute\SpecializationContextHashInterface;
+use Markup\NeedleBundle\Context\ContextFilterFactory;
+use Markup\NeedleBundle\Facet\RangeFacetField;
+use Markup\NeedleBundle\Filter\FilterValueInterface;
+use Markup\NeedleBundle\Filter\RangeFilterValue;
+use Markup\NeedleBundle\Filter\UnionFilterValue;
+use PHPUnit\Framework\TestCase;
+
+class ContextFilterFactoryTest extends TestCase
+{
+    /**
+     * @dataProvider rangeUnionDataProvider
+     *
+     * @param float $rangeSize
+     * @param mixed $filterValue
+     * @param FilterValueInterface|null $expectedFilterValue
+     * @param bool $throwsException
+     */
+    public function testRangeUnion(
+        $filterValue,
+        float $rangeSize,
+        ?FilterValueInterface $expectedFilterValue,
+        bool $throwsException
+    ): void {
+        $attributeMock = $this->createMock(RangeFacetField::class);
+        $attributeMock->method('getRangeSize')->willReturn($rangeSize);
+
+        $attributeProviderMock = $this->createMock(AttributeProviderInterface::class);
+        $attributeProviderMock->method('getAttributeByName')->willReturn($attributeMock);
+
+        $specializationContextHashMock = $this->createMock(SpecializationContextHashInterface::class);
+
+        $factory = new ContextFilterFactory($attributeProviderMock);
+        if ($throwsException) {
+            $this->expectException(\RuntimeException::class);
+        }
+        $result = $factory->create('', $filterValue, $specializationContextHashMock);
+        if (!$result) {
+            $this->assertSame($expectedFilterValue, $result);
+        } else {
+            $this->assertEquals($expectedFilterValue, $result->getFilterValue());
+        }
+    }
+
+    public function rangeUnionDataProvider(): array
+    {
+        return [
+            'two simple values' => [
+                ['50', '150'],
+                50,
+                new UnionFilterValue([
+                    new RangeFilterValue(50, 99.99),
+                    new RangeFilterValue(150, 199.99),
+                ]),
+                false,
+            ],
+            'multiple overlapping values not in order' => [
+                ['87.51', '42.84', '150.01'],
+                50.5,
+                new UnionFilterValue([
+                    new RangeFilterValue(87.51, 138),
+                    new RangeFilterValue(42.84, 93.33),
+                    new RangeFilterValue(150.01, 200.5),
+                ]),
+                false,
+            ],
+            'one value' => [
+                ['75'],
+                2.5,
+                new RangeFilterValue(75, 77.49),
+                false,
+            ],
+            'explicit min and max' => [
+                ['min' => 15.2, 'max' => 99.5],
+                -256,
+                new RangeFilterValue(15.2, 99.5),
+                false,
+            ],
+            'zero values' => [
+                [],
+                50,
+                null,
+                true,
+            ],
+            'value not an array' => [
+                '150',
+                50,
+                null,
+                true,
+            ]
+        ];
+    }
+}

src/Context/ContextFilterFactory.php

@@ -66,25 +66,39 @@ function ($value) {
         return new SearchFilter\FilterQuery($attribute, new SearchFilter\ScalarFilterValue($filterValue));
     }
 
-    // if the value can/should be interpreted as a range filter value then one is returned
-    private function getRangeFilterValue(AttributeInterface $attribute, $filterValue): ?SearchFilter\RangeFilterValue
-    {
+    /**
+     * If the value should be interpreted as a range filter or a collection of range filters then one is returned.
+     *
+     * @param AttributeInterface $attribute
+     * @param mixed $filterValue
+     * @return SearchFilter\FilterValueInterface|null
+     */
+    private function getRangeFilterValue(
+        AttributeInterface $attribute,
+        $filterValue
+    ): ?SearchFilter\FilterValueInterface {
         if ($attribute instanceof RangeFacetField) {
-            if (is_array($filterValue) && isset($filterValue['min'], $filterValue['max'])) {
+            if (!is_array($filterValue) || empty($filterValue)) {
+                throw new \RuntimeException('Cannot provide range filter value given the passed filter values');
+            }
+
+            if (isset($filterValue['min'], $filterValue['max'])) {
                 return new SearchFilter\RangeFilterValue(
                     floatval($filterValue['min']),
                     floatval($filterValue['max'])
                 );
             }
 
-            if (is_array($filterValue)) {
-                $min = floatval(min($filterValue));
-                $max = floatval(max($filterValue)) + (floatval($attribute->getRangeSize()) - 0.01);
-
-                return new SearchFilter\RangeFilterValue($min, $max);
+            $ranges = [];
+            foreach ($filterValue as $min) {
+                $min = floatval($min);
+                $max = $min + $attribute->getRangeSize() - 0.01;
+                $ranges[] = new SearchFilter\RangeFilterValue($min, $max);
             }
-
-            throw new \RuntimeException('Cannot provide range filter value given the passed filter values');
+            if (count($ranges) === 1) {
+                return $ranges[0];
+            }
+            return new SearchFilter\UnionFilterValue($ranges);
         }
 
         if (!$attribute instanceof FloatAttributeInterface) {