partkeepr

fork of partkeepr
git clone https://git.e1e0.net/partkeepr.git
Log | Files | Refs | Submodules | README | LICENSE

AdvancedSearchFilterTest.php (8253B)


      1 <?php
      2 
      3 namespace PartKeepr\DoctrineReflectionBundle\Tests;
      4 
      5 use Doctrine\Common\DataFixtures\ProxyReferenceRepository;
      6 use Dunglas\ApiBundle\Api\IriConverter;
      7 use PartKeepr\CoreBundle\Tests\WebTestCase;
      8 
      9 class AdvancedSearchFilterTest extends WebTestCase
     10 {
     11     /**
     12      * @var ProxyReferenceRepository
     13      */
     14     protected $fixtures;
     15 
     16     public function setUp()
     17     {
     18         $this->fixtures = $this->loadFixtures(
     19             [
     20                 'PartKeepr\StorageLocationBundle\DataFixtures\CategoryDataLoader',
     21                 'PartKeepr\StorageLocationBundle\DataFixtures\StorageLocationLoader',
     22                 'PartKeepr\PartBundle\DataFixtures\CategoryDataLoader',
     23                 'PartKeepr\PartBundle\DataFixtures\PartDataLoader',
     24                 'PartKeepr\ManufacturerBundle\Tests\DataFixtures\ManufacturerDataLoader',
     25                 'PartKeepr\DistributorBundle\Tests\DataFixtures\DistributorDataLoader',
     26             ]
     27         )->getReferenceRepository();
     28     }
     29 
     30     public function testEqualFilter()
     31     {
     32         $client = static::makeClient(true);
     33 
     34         $filter = [
     35             [
     36                 "property" => "storageLocation.name",
     37                 "operator" => "=",
     38                 "value"    => "test",
     39             ],
     40         ];
     41 
     42         $client->request(
     43             'GET',
     44             "/api/parts?filter=".json_encode($filter),
     45             [],
     46             [],
     47             ['CONTENT_TYPE' => 'application/json']
     48         );
     49 
     50         $data = json_decode($client->getResponse()->getContent(), true);
     51 
     52         $this->assertArrayHasKey("hydra:member", $data);
     53         $this->assertCount(1, $data["hydra:member"]);
     54         $this->assertArrayHasKey("@id", $data["hydra:member"][0]);
     55 
     56         /**
     57          * @var IriConverter
     58          */
     59         $iriConverter = $this->getContainer()->get('api.iri_converter');
     60 
     61         $this->assertEquals(
     62             $iriConverter->getIriFromItem($this->fixtures->getReference("part.1")),
     63             $data["hydra:member"][0]["@id"]
     64         );
     65     }
     66 
     67     public function testEqualFilterSame()
     68     {
     69         $client = static::makeClient(true);
     70 
     71         $filter = [
     72             [
     73                 "property" => "name",
     74                 "operator" => "=",
     75                 "value"    => "FOOBAR",
     76             ],
     77         ];
     78 
     79         $client->request(
     80             'GET',
     81             "/api/parts?filter=".json_encode($filter),
     82             [],
     83             [],
     84             ['CONTENT_TYPE' => 'application/json']
     85         );
     86 
     87         $data = json_decode($client->getResponse()->getContent(), true);
     88 
     89         $this->assertArrayHasKey("hydra:member", $data);
     90         $this->assertCount(1, $data["hydra:member"]);
     91         $this->assertArrayHasKey("@id", $data["hydra:member"][0]);
     92 
     93         /**
     94          * @var IriConverter
     95          */
     96         $iriConverter = $this->getContainer()->get('api.iri_converter');
     97 
     98         $this->assertEquals(
     99             $iriConverter->getIriFromItem($this->fixtures->getReference("part.1")),
    100             $data["hydra:member"][0]["@id"]
    101         );
    102     }
    103 
    104     public function testIDReference()
    105     {
    106         $client = static::makeClient(true);
    107 
    108         /**
    109          * @var IriConverter
    110          */
    111         $iriConverter = $this->getContainer()->get('api.iri_converter');
    112 
    113         $filter = [
    114             [
    115                 "property" => "storageLocation",
    116                 "operator" => "=",
    117                 "value"    => $iriConverter->getIriFromItem($this->fixtures->getReference("storagelocation.first")),
    118             ],
    119         ];
    120 
    121         $client->request(
    122             'GET',
    123             "/api/parts?filter=".json_encode($filter),
    124             [],
    125             [],
    126             ['CONTENT_TYPE' => 'application/json']
    127         );
    128 
    129         $data = json_decode($client->getResponse()->getContent(), true);
    130 
    131         $this->assertArrayHasKey("hydra:member", $data);
    132         $this->assertCount(1, $data["hydra:member"]);
    133     }
    134 
    135     public function testIDReferenceArray()
    136     {
    137         $client = static::makeClient(true);
    138 
    139         /**
    140          * @var IriConverter
    141          */
    142         $iriConverter = $this->getContainer()->get('api.iri_converter');
    143 
    144         $filter = [
    145             [
    146                 "property" => "storageLocation",
    147                 "operator" => "IN",
    148                 "value"    => [
    149                     $iriConverter->getIriFromItem($this->fixtures->getReference("storagelocation.first")),
    150                     $iriConverter->getIriFromItem($this->fixtures->getReference("storagelocation.second")),
    151                 ],
    152             ],
    153         ];
    154 
    155         $client->request(
    156             'GET',
    157             "/api/parts?filter=".json_encode($filter),
    158             [],
    159             [],
    160             ['CONTENT_TYPE' => 'application/json']
    161         );
    162 
    163         $data = json_decode($client->getResponse()->getContent(), true);
    164 
    165         $this->assertArrayHasKey("hydra:member", $data);
    166         $this->assertGreaterThan(1, $data["hydra:member"]);
    167     }
    168 
    169     public function testLikeFilter()
    170     {
    171         $client = static::makeClient(true);
    172 
    173         $filter = [
    174             [
    175                 "property" => "storageLocation.name",
    176                 "operator" => "LIKE",
    177                 "value"    => "%test%",
    178             ],
    179         ];
    180 
    181         $client->request(
    182             'GET',
    183             "/api/parts?filter=".json_encode($filter),
    184             [],
    185             [],
    186             ['CONTENT_TYPE' => 'application/json']
    187         );
    188 
    189         $data = json_decode($client->getResponse()->getContent(), true);
    190 
    191         $this->assertArrayHasKey("hydra:member", $data);
    192         $this->assertGreaterThanOrEqual(2, $data["hydra:member"]);
    193     }
    194 
    195     public function testSorter()
    196     {
    197         $client = static::makeClient(true);
    198 
    199         $order = [
    200             [
    201                 "property"  => "storageLocation.name",
    202                 "direction" => "ASC",
    203             ],
    204         ];
    205 
    206         $client->request(
    207             'GET',
    208             "/api/parts?order=".json_encode($order),
    209             [],
    210             [],
    211             ['CONTENT_TYPE' => 'application/json']
    212         );
    213 
    214         $data = json_decode($client->getResponse()->getContent(), true);
    215 
    216         $this->assertArrayHasKey("hydra:member", $data);
    217         $this->assertGreaterThanOrEqual(2, $data["hydra:member"]);
    218     }
    219 
    220     public function testOrFilterJoin()
    221     {
    222         $client = static::makeClient(true);
    223 
    224         $filter = [
    225             [
    226                 "type"       => "OR",
    227                 "subfilters" => [
    228                     [
    229                         "property" => "storageLocation.name",
    230                         "operator" => "=",
    231                         "value"    => "test",
    232                     ],
    233                     [
    234                         "property" => "storageLocation.name",
    235                         "operator" => "=",
    236                         "value"    => "test2",
    237                     ],
    238                 ],
    239             ],
    240         ];
    241 
    242         $client->request(
    243             'GET',
    244             "/api/parts?filter=".json_encode($filter),
    245             [],
    246             [],
    247             ['CONTENT_TYPE' => 'application/json']
    248         );
    249 
    250         $data = json_decode($client->getResponse()->getContent(), true);
    251 
    252         $this->assertArrayHasKey("hydra:member", $data);
    253         $this->assertGreaterThanOrEqual(2, $data["hydra:member"]);
    254     }
    255 
    256     public function testOrFilter()
    257     {
    258         $client = static::makeClient(true);
    259 
    260         $filter = [
    261             [
    262                 "type"       => "OR",
    263                 "subfilters" => [
    264                     [
    265                         "property" => "name",
    266                         "operator" => "=",
    267                         "value"    => "FOOBAR",
    268                     ],
    269                     [
    270                         "property" => "name",
    271                         "operator" => "=",
    272                         "value"    => "FOOBAR2",
    273                     ],
    274                 ],
    275             ],
    276         ];
    277 
    278         $client->request(
    279             'GET',
    280             "/api/parts?filter=".json_encode($filter),
    281             [],
    282             [],
    283             ['CONTENT_TYPE' => 'application/json']
    284         );
    285 
    286         $data = json_decode($client->getResponse()->getContent(), true);
    287 
    288         $this->assertArrayHasKey("hydra:member", $data);
    289         $this->assertCount(2, $data["hydra:member"]);
    290     }
    291 }