Lexical: Updated tests for node changes

[bookstack] / tests / Entity / SearchOptionsTest.php

diff --git a/tests/Entity/SearchOptionsTest.php b/tests/Entity/SearchOptionsTest.php
index ea4d727a42850002353b686823ce362a048b4395..0c2ad271c58892df4bfc7b186f948a76bf5b20b5 100644 (file)
--- a/tests/Entity/SearchOptionsTest.php
+++ b/tests/Entity/SearchOptionsTest.php
@@ -2,7 +2,12 @@
 
 namespace Tests\Entity;
 
 
 namespace Tests\Entity;
 

+use BookStack\Search\Options\ExactSearchOption;
+use BookStack\Search\Options\FilterSearchOption;
+use BookStack\Search\Options\TagSearchOption;
+use BookStack\Search\Options\TermSearchOption;

 use BookStack\Search\SearchOptions;
 use BookStack\Search\SearchOptions;

+use BookStack\Search\SearchOptionSet;

 use Illuminate\Http\Request;
 use Tests\TestCase;
 
 use Illuminate\Http\Request;
 use Tests\TestCase;
 


@@ -12,27 +17,57 @@ class SearchOptionsTest extends TestCase
     {
         $options = SearchOptions::fromString('cat "dog" [tag=good] {is_tree}');
 
     {
         $options = SearchOptions::fromString('cat "dog" [tag=good] {is_tree}');
 

-        $this->assertEquals(['cat'], $options->searches);
-        $this->assertEquals(['dog'], $options->exacts);
-        $this->assertEquals(['tag=good'], $options->tags);
-        $this->assertEquals(['is_tree' => ''], $options->filters);
+        $this->assertEquals(['cat'], $options->searches->toValueArray());
+        $this->assertEquals(['dog'], $options->exacts->toValueArray());
+        $this->assertEquals(['tag=good'], $options->tags->toValueArray());
+        $this->assertEquals(['is_tree' => ''], $options->filters->toValueMap());
+    }
+
+    public function test_from_string_parses_negations()
+    {
+        $options = SearchOptions::fromString('cat -"dog" -[tag=good] -{is_tree}');
+
+        $this->assertEquals(['cat'], $options->searches->toValueArray());
+        $this->assertTrue($options->exacts->all()[0]->negated);
+        $this->assertTrue($options->tags->all()[0]->negated);
+        $this->assertTrue($options->filters->all()[0]->negated);

     }
 
     public function test_from_string_properly_parses_escaped_quotes()
     {
         $options = SearchOptions::fromString('"\"cat\"" surprise "\"\"" "\"donkey" "\"" "\\\\"');
 
     }
 
     public function test_from_string_properly_parses_escaped_quotes()
     {
         $options = SearchOptions::fromString('"\"cat\"" surprise "\"\"" "\"donkey" "\"" "\\\\"');
 

-        $this->assertEquals(['"cat"', '""', '"donkey', '"', '\\'], $options->exacts);
+        $this->assertEquals(['"cat"', '""', '"donkey', '"', '\\'], $options->exacts->toValueArray());

     }
 
     public function test_to_string_includes_all_items_in_the_correct_format()
     {
     }
 
     public function test_to_string_includes_all_items_in_the_correct_format()
     {

-        $expected = 'cat "dog" [tag=good] {is_tree}';
+        $expected = 'cat "dog" [tag=good] {is_tree} {beans:valid}';

         $options = new SearchOptions();
         $options = new SearchOptions();

-        $options->searches = ['cat'];
-        $options->exacts = ['dog'];
-        $options->tags = ['tag=good'];
-        $options->filters = ['is_tree' => ''];
+        $options->searches = SearchOptionSet::fromValueArray(['cat'], TermSearchOption::class);
+        $options->exacts = SearchOptionSet::fromValueArray(['dog'], ExactSearchOption::class);
+        $options->tags = SearchOptionSet::fromValueArray(['tag=good'], TagSearchOption::class);
+        $options->filters = new SearchOptionSet([
+            new FilterSearchOption('', 'is_tree'),
+            new FilterSearchOption('valid', 'beans'),
+        ]);
+
+        $output = $options->toString();
+        foreach (explode(' ', $expected) as $term) {
+            $this->assertStringContainsString($term, $output);
+        }
+    }
+
+    public function test_to_string_handles_negations_as_expected()
+    {
+        $expected = 'cat -"dog" -[tag=good] -{is_tree}';
+        $options = new SearchOptions();
+        $options->searches = new SearchOptionSet([new TermSearchOption('cat')]);
+        $options->exacts = new SearchOptionSet([new ExactSearchOption('dog', true)]);
+        $options->tags = new SearchOptionSet([new TagSearchOption('tag=good', true)]);
+        $options->filters = new SearchOptionSet([
+            new FilterSearchOption('', 'is_tree', true),
+        ]);

 
         $output = $options->toString();
         foreach (explode(' ', $expected) as $term) {
 
         $output = $options->toString();
         foreach (explode(' ', $expected) as $term) {


@@ -43,7 +78,7 @@ class SearchOptionsTest extends TestCase
     public function test_to_string_escapes_as_expected()
     {
         $options = new SearchOptions();
     public function test_to_string_escapes_as_expected()
     {
         $options = new SearchOptions();

-        $options->exacts = ['"cat"', '""', '"donkey', '"', '\\', '\\"'];
+        $options->exacts = SearchOptionSet::fromValueArray(['"cat"', '""', '"donkey', '"', '\\', '\\"'], ExactSearchOption::class);

 
         $output = $options->toString();
         $this->assertEquals('"\"cat\"" "\"\"" "\"donkey" "\"" "\\\\" "\\\\\""', $output);
 
         $output = $options->toString();
         $this->assertEquals('"\"cat\"" "\"\"" "\"donkey" "\"" "\\\\" "\\\\\""', $output);


@@ -57,14 +92,14 @@ class SearchOptionsTest extends TestCase
             'is_tree' => '',
             'name'    => 'dan',
             'cat'     => 'happy',
             'is_tree' => '',
             'name'    => 'dan',
             'cat'     => 'happy',

-        ], $opts->filters);
+        ], $opts->filters->toValueMap());

     }
     public function test_it_cannot_parse_out_empty_exacts()
     {
         $options = SearchOptions::fromString('"" test ""');
 
     }
     public function test_it_cannot_parse_out_empty_exacts()
     {
         $options = SearchOptions::fromString('"" test ""');
 

-        $this->assertEmpty($options->exacts);
-        $this->assertCount(1, $options->searches);
+        $this->assertEmpty($options->exacts->toValueArray());
+        $this->assertCount(1, $options->searches->toValueArray());

     }
 
     public function test_from_request_properly_parses_exacts_from_search_terms()
     }
 
     public function test_from_request_properly_parses_exacts_from_search_terms()


@@ -74,7 +109,37 @@ class SearchOptionsTest extends TestCase
         ]);
 
         $options = SearchOptions::fromRequest($request);
         ]);
 
         $options = SearchOptions::fromRequest($request);

-        $this->assertEquals(["biscuits"], $options->searches);
-        $this->assertEquals(['"cheese"', '""', '"baked',  'beans"'], $options->exacts);
+        $this->assertEquals(["biscuits"], $options->searches->toValueArray());
+        $this->assertEquals(['"cheese"', '""', '"baked',  'beans"'], $options->exacts->toValueArray());
+    }
+
+    public function test_from_request_properly_parses_provided_types()
+    {
+        $request = new Request([
+            'search' => '',
+            'types' => ['page', 'book'],
+        ]);
+
+        $options = SearchOptions::fromRequest($request);
+        $filters = $options->filters->toValueMap();
+        $this->assertCount(1, $filters);
+        $this->assertEquals('page|book', $filters['type'] ?? 'notfound');
+    }
+
+    public function test_from_request_properly_parses_out_extras_as_string()
+    {
+        $request = new Request([
+            'search' => '',
+            'tags' => ['a=b'],
+            'extras' => '-[b=c] -{viewed_by_me} -"dino"'
+        ]);
+
+        $options = SearchOptions::fromRequest($request);
+        $this->assertCount(2, $options->tags->all());
+        $this->assertEquals('b=c', $options->tags->negated()->all()[0]->value);
+        $this->assertEquals('viewed_by_me', $options->filters->all()[0]->getKey());
+        $this->assertTrue($options->filters->all()[0]->negated);
+        $this->assertEquals('dino', $options->exacts->all()[0]->value);
+        $this->assertTrue($options->exacts->all()[0]->negated);

     }
 }
     }
 }