praxis 2.0.pre.8 → 2.0.pre.13

data/spec/praxis/bootloader_spec.rb

@@ -44,7 +44,11 @@ describe Praxis::Bootloader do
       expect(bootloader.before(stage.name)).to eq('before!')
     end
 
-    it "raises when given an invalid stage name"
+    it "raises when given an invalid stage name" do
+      expect{
+        bootloader.before('nope!')
+      }.to raise_error(Praxis::Exceptions::StageNotFound,/Error running a before block for stage nope!/)
+    end
   end
 
   context ".after" do
@@ -54,7 +58,11 @@ describe Praxis::Bootloader do
       expect(bootloader.after(stage.name)).to eq('after!')
     end
 
-    it "raises when given an invalid stage name"
+    it "raises when given an invalid stage name" do
+      expect{
+        bootloader.after('nope!')
+      }.to raise_error(Praxis::Exceptions::StageNotFound,/Error running an after block for stage nope!/)
+    end
   end
 
   context ".use" do

data/spec/praxis/collection_spec.rb

@@ -51,19 +51,6 @@ describe Praxis::Collection do
     its(:identifier) { should eq Person.identifier + "; type=collection" }
   end
 
-  context '.views' do
-    subject(:views) { collection.views }
-    its(:keys) { should match_array(member_type.views.keys)}
-
-    it 'generates CollectionViews from the member views' do
-      collection.views.each do |name, view|
-        expect(view.name).to be name
-        expect(view.schema).to be member_type
-        expect(view.contents).to eq member_type.views[name].contents
-      end
-    end
-  end
-
   context '.load' do
     let(:volume_data) do
       {

data/spec/praxis/config_hash_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Praxis::ConfigHash do
+  subject(:instance) { Praxis::ConfigHash.new(hash, &block) }
+  let(:hash) { { one: ['existing'], two: 'dos' } }
+  let(:block) do
+    proc { 'abc' }
+  end
+
+  context 'initialization' do
+    it 'saves the passed hash' do
+      expect(subject.hash).to be(hash)
+    end
+  end
+
+  context '.from' do
+    subject(:instance) { Praxis::ConfigHash.from(hash, &block) }
+    it 'returns an instance' do
+      expect(subject).to be_kind_of(Praxis::ConfigHash)
+      expect(subject.hash).to be(hash)
+    end
+  end
+
+  context '#to_hash' do
+    let(:block) do
+      proc { hash['i_was'] = 'here' }
+    end
+    it 'evaluates the block and returns the resulting hash' do
+      expect(subject.to_hash).to eq(subject.hash)
+      expect(subject.hash['i_was']).to eq('here')
+    end
+  end
+
+  context '#method_missing' do
+    context 'when keys do not exist in the hash key' do
+      it 'sets a single value to the hash' do
+        subject.some_name 'someval'
+        expect(subject.hash[:some_name]).to eq('someval')
+      end
+      it 'sets a multiple values to the hash key' do
+        subject.some_name 'someval', 'other1', 'other2'
+        expect(subject.hash[:some_name]).to include('someval', 'other1', 'other2')
+      end
+    end
+    context 'when keys already exist in the hash key' do
+      it 'adds one value to the hash' do
+        subject.one'newval'
+        expect(subject.hash[:one]).to match_array(%w(existing newval))
+      end
+      it 'adds multiple values to the hash key' do
+        subject.one 'newval', 'other1', 'other2'
+        expect(subject.hash[:one]).to match_array(%w(existing newval other1 other2))
+      end
+      context 'when passing a value and a block' do
+        let(:my_block) { proc {} }
+        it 'adds the tuple to the hash key' do
+          subject.one 'val', &my_block
+          expect(subject.hash[:one]).to include(['val', my_block])
+        end
+      end
+    end
+  end
+end

data/spec/praxis/{resource_definition_spec.rb → endpoint_definition_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Praxis::ResourceDefinition do
-  subject(:resource_definition) { PeopleResource }
+describe Praxis::EndpointDefinition do
+  subject(:endpoint_definition) { PeopleResource }
 
   its(:description) { should eq('People resource') }
   its(:media_type) { should eq(Person) }
@@ -14,10 +14,10 @@ describe Praxis::ResourceDefinition do
   its(:metadata) { should_not have_key(:doc_visibility) }
 
   context '.describe' do
-    subject(:describe) { resource_definition.describe }
+    subject(:describe) { endpoint_definition.describe }
 
-    its([:description]) { should eq(resource_definition.description) }
-    its([:media_type]) { should eq(resource_definition.media_type.describe(true)) }
+    its([:description]) { should eq(endpoint_definition.description) }
+    its([:media_type]) { should eq(endpoint_definition.media_type.describe(true)) }
 
     its([:actions]) { should have(2).items }
     its([:metadata]) { should be_kind_of(Hash) }
@@ -25,7 +25,7 @@ describe Praxis::ResourceDefinition do
     it { should_not have_key(:parent)}
 
     context 'for a resource with a parent' do
-      let(:resource_definition) { ApiResources::VolumeSnapshots}
+      let(:endpoint_definition) { ApiResources::VolumeSnapshots}
 
       its([:parent]) { should eq ApiResources::Volumes.id }
     end
@@ -34,29 +34,29 @@ describe Praxis::ResourceDefinition do
 
 
   context '.routing_prefix' do
-    subject(:resource_definition) { ApiResources::VolumeSnapshots }
+    subject(:endpoint_definition) { ApiResources::VolumeSnapshots }
     it do
-      expect(resource_definition.routing_prefix).to eq('/clouds/:cloud_id/volumes/:volume_id/snapshots')
+      expect(endpoint_definition.routing_prefix).to eq('/clouds/:cloud_id/volumes/:volume_id/snapshots')
     end
   end
 
   context '.parent_prefix' do
-    subject(:resource_definition) { ApiResources::VolumeSnapshots }
+    subject(:endpoint_definition) { ApiResources::VolumeSnapshots }
     let(:base_path){ Praxis::ApiDefinition.instance.info.base_path }
     its(:parent_prefix){ should eq('/clouds/:cloud_id/volumes/:volume_id') }
     it do
-      expect(resource_definition.parent_prefix).to_not match(/^#{base_path}/)
+      expect(endpoint_definition.parent_prefix).to_not match(/^#{base_path}/)
     end
   end
 
 
   context '.action' do
     it 'requires a block' do
-      expect { resource_definition.action(:something)
+      expect { endpoint_definition.action(:something)
                }.to raise_error(ArgumentError)
     end
     it 'creates an ActionDefinition for actions' do
-      index = resource_definition.actions[:index]
+      index = endpoint_definition.actions[:index]
       expect(index).to be_kind_of(Praxis::ActionDefinition)
       expect(index.description).to eq("index description")
     end
@@ -64,7 +64,7 @@ describe Praxis::ResourceDefinition do
     it 'complains if action names are not symbols' do
       expect do
         Class.new do
-          include Praxis::ResourceDefinition
+          include Praxis::EndpointDefinition
           action "foo" do
           end
         end
@@ -73,9 +73,9 @@ describe Praxis::ResourceDefinition do
   end
 
   context 'action_defaults' do
-    let(:resource_definition) do
+    let(:endpoint_definition) do
       Class.new do
-        include Praxis::ResourceDefinition
+        include Praxis::EndpointDefinition
         media_type Person
 
         version '1.0'
@@ -135,13 +135,13 @@ describe Praxis::ResourceDefinition do
     end
 
     it 'are applied to actions' do
-      action = resource_definition.actions[:show]
+      action = endpoint_definition.actions[:show]
       expect(action.params.attributes).to have_key(:id)
       expect(action.route.path.to_s).to eq '/api/:base_param/people/:id'
     end
 
     context 'includes base_params from the APIDefinition' do
-      let(:show_action_params){ resource_definition.actions[:show].params }
+      let(:show_action_params){ endpoint_definition.actions[:show].params }
 
       it 'including globally defined' do
         expect(show_action_params.attributes).to have_key(:base_param)
@@ -159,15 +159,15 @@ describe Praxis::ResourceDefinition do
   end
 
   context 'setting other values' do
-    subject(:resource_definition) { Class.new {include Praxis::ResourceDefinition } }
+    subject(:endpoint_definition) { Class.new {include Praxis::EndpointDefinition } }
 
     let(:some_proc) { Proc.new {} }
     let(:some_hash) { Hash.new }
 
     it 'accepts a string as media_type' do
-      resource_definition.media_type('Something')
-      expect(resource_definition.media_type).to be_kind_of(Praxis::SimpleMediaType)
-      expect(resource_definition.media_type.identifier).to eq('Something')
+      endpoint_definition.media_type('Something')
+      expect(endpoint_definition.media_type).to be_kind_of(Praxis::SimpleMediaType)
+      expect(endpoint_definition.media_type.identifier).to eq('Something')
     end
 
     its(:version_options){ should be_kind_of(Hash) }
@@ -176,57 +176,30 @@ describe Praxis::ResourceDefinition do
 
 
   context '.trait' do
-    subject(:resource_definition) { Class.new {include Praxis::ResourceDefinition } }
+    subject(:endpoint_definition) { Class.new {include Praxis::EndpointDefinition } }
     it 'raises an error for missing traits' do
-      expect { resource_definition.use(:stuff) }.to raise_error(Praxis::Exceptions::InvalidTrait)
+      expect { endpoint_definition.trait(:stuff) }.to raise_error(Praxis::Exceptions::InvalidTrait)
     end
-    it 'has a spec for actually using a trait'
-  end
-
-
-  context 'deprecated action methods' do
-    subject(:resource_definition) do
-      Class.new do
-        include Praxis::ResourceDefinition
-
-        def self.name
-          'FooBar'
-        end
+    it 'adds it to its list when it is available in the APIDefinition instance' do
+      trait_name = :test
+      expect(endpoint_definition.traits).to_not include(trait_name)
 
-        silence_warnings do
-          payload { attribute :inherited_payload, String }
-          headers { key "Inherited-Header", String }
-          params  { attribute :inherited_params, String }
-          response :not_found
-        end
-
-        action :index do
-        end
-      end
+      endpoint_definition.trait(trait_name)
+      expect(endpoint_definition.traits).to include(trait_name)
     end
-
-    let(:action) { resource_definition.actions[:index] }
-
-    it 'are applied to the action' do
-      expect(action.payload.attributes).to have_key(:inherited_payload)
-      expect(action.headers.attributes).to have_key("Inherited-Header")
-      expect(action.params.attributes).to have_key(:inherited_params)
-      expect(action.responses).to have_key(:not_found)
-    end
-
   end
 
   context 'with nodoc! called' do
     before do
-      resource_definition.nodoc!
+      endpoint_definition.nodoc!
     end
 
     it 'has the :doc_visibility option set' do
-      expect(resource_definition.metadata[:doc_visibility]).to be(:none)
+      expect(endpoint_definition.metadata[:doc_visibility]).to be(:none)
     end
 
     it 'is exposed in the describe' do
-      expect(resource_definition.describe[:metadata][:doc_visibility]).to be(:none)
+      expect(endpoint_definition.describe[:metadata][:doc_visibility]).to be(:none)
     end
 
   end
@@ -238,14 +211,14 @@ describe Praxis::ResourceDefinition do
       end
       it 'cannot be done if already been defined' do
         expect{
-          resource_definition.canonical_path :reset
+          endpoint_definition.canonical_path :reset
         }.to raise_error(/'canonical_path' can only be defined once./)
       end
     end
     context 'if none specified' do
-      subject(:resource_definition) do
+      subject(:endpoint_definition) do
         Class.new do
-          include Praxis::ResourceDefinition
+          include Praxis::EndpointDefinition
           action :show do
           end
         end
@@ -255,9 +228,9 @@ describe Praxis::ResourceDefinition do
       end
     end
     context 'with an undefined action' do
-      subject(:resource_definition) do
+      subject(:endpoint_definition) do
         Class.new do
-          include Praxis::ResourceDefinition
+          include Praxis::EndpointDefinition
           canonical_path :non_existent
         end
       end
@@ -275,7 +248,7 @@ describe Praxis::ResourceDefinition do
     end
   end
   context '#parse_href' do
-    let(:parsed){ resource_definition.parse_href("/people/1") }
+    let(:parsed){ endpoint_definition.parse_href("/people/1") }
     it 'accesses the path expansion functions of the primary route' do
       expect(parsed).to have_key(:id)
     end

data/spec/praxis/extensions/attribute_filtering/active_record_filter_query_builder_spec.rb

@@ -14,6 +14,7 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
   shared_examples 'subject_equivalent_to' do |expected_result|
     it do
       loaded_ids = subject.all.map(&:id).sort
+      expected_result = expected_result.call if expected_result.is_a?(Proc)
       expected_ids = expected_result.all.map(&:id).sort
       expect(loaded_ids).to_not be_empty
       expect(loaded_ids).to eq(expected_ids)
@@ -23,12 +24,11 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
   # Poorman's way to compare SQL queries...
   shared_examples 'subject_matches_sql' do |expected_sql|
     it do
-       # Remove parenthesis as our queries have WHERE clauses using them...
-      gen_sql = subject.all.to_sql.gsub(/[()]/,'')
+      gen_sql = subject.all.to_sql
       # Strip blank at the beggining (and end) of every line
       # ...and recompose it by adding an extra space at the beginning of each one instead
       exp = expected_sql.split(/\n/).map do |line|
-        " " + line.strip.gsub(/[()]/,'')
+        " " + line.strip
       end.join.strip
       expect(gen_sql).to eq(exp)
     end
@@ -37,9 +37,9 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
   context 'initialize' do
     it 'sets the right things to the instance' do
       instance
-      expect(instance.query).to eq(base_query)
+      expect(instance.instance_variable_get(:@initial_query)).to eq(base_query)
       expect(instance.model).to eq(base_model)
-      expect(instance.attr_to_column).to eq(filters_map)
+      expect(instance.filters_map).to eq(filters_map)
     end
   end
   context 'generate' do
@@ -52,197 +52,278 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
         expect(subject).to be(base_query)
       end
     end
-    context 'by a simple field' do
-      context 'that maps to the same name' do
-        let(:filters_string) { 'category_uuid=deadbeef1' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1')
-      end
-      context 'that maps to a different name' do
-        let(:filters_string) { 'name=Book1'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.where(simple_name: 'Book1')
-      end
-      context 'that is mapped as a nested struct' do
-        let(:filters_string) { 'fake_nested.name=Book1'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.where(simple_name: 'Book1')
-      end
-    end
+    context 'with flat AND conditions' do
+      context 'by a simple field' do
+        context 'that maps to the same name' do
+          let(:filters_string) { 'category_uuid=deadbeef1' }
+          it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1')
+        end
+        context 'same-name filter mapping works' do
+          context 'even if ther was not a filter explicitly defined for it' do
+            let(:filters_string) { 'category_uuid=deadbeef1' }
+            it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1')
+          end
 
-    context 'by a field or a related model' do
-      context 'for a belongs_to association' do
-        let(:filters_string) { 'author.name=author2'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name' => 'author2')
-      end
-      context 'for a has_many association' do
-        let(:filters_string) { 'taggings.label=primary' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:taggings).where('active_taggings.label' => 'primary')
-      end
-      context 'for a has_many through association' do
-        let(:filters_string) { 'tags.name=blue' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:tags).where('active_tags.name' => 'blue')
+          context 'but if it is a field that does not exist in the model' do
+            let(:filters_string) { 'nonexisting=valuehere' }
+            it 'it blows up with the right error' do
+              expect{subject}.to raise_error(/Filtering by nonexisting is not allowed/)
+            end
+          end
+        end
+          context 'that maps to a different name' do
+          let(:filters_string) { 'name=Book1'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.where(simple_name: 'Book1')
+        end
+        context 'that is mapped as a nested struct' do
+          let(:filters_string) { 'fake_nested.name=Book1'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.where(simple_name: 'Book1')
+        end
       end
-    end
 
-    context 'by using all supported operators' do
-      PREF = Praxis::Extensions::AttributeFiltering::ALIAS_TABLE_PREFIX
-      COMMON_SQL_PREFIX = <<~SQL
-            SELECT "active_books".* FROM "active_books"
-            INNER JOIN
-              "active_authors" "#{PREF}/author" ON "#{PREF}/author"."id" = "active_books"."author_id"
-          SQL
-      context '=' do
-        let(:filters_string) { 'author.id=11'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id = 11')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" = 11
-          SQL
-      end
-      context '= (with array)' do
-        let(:filters_string) { 'author.id=11,22'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id IN (11,22)')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" IN (11,22)
-          SQL
-      end      
-      context '!=' do
-        let(:filters_string) { 'author.id!=11'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id <> 11')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" <> 11
-          SQL
-      end
-      context '!= (with array)' do
-        let(:filters_string) { 'author.id!=11,888'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id NOT IN (11,888)')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" NOT IN (11,888)
-          SQL
-      end
-      context '>' do
-        let(:filters_string) { 'author.id>1'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id > 1')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" > 1
-          SQL
-      end
-      context '<' do
-        let(:filters_string) { 'author.id<22'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id < 22')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" < 22
-          SQL
-      end
-      context '>=' do
-        let(:filters_string) { 'author.id>=22'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id >= 22')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" >= 22
-          SQL
-      end
-      context '<=' do
-        let(:filters_string) { 'author.id<=22'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id <= 22')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" <= 22
-          SQL
-      end
-      context '!' do
-        let(:filters_string) { 'author.id!'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id IS NOT NULL')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."id" IS NOT NULL
-          SQL
+      context 'by a field or a related model' do
+        context 'for a belongs_to association' do
+          let(:filters_string) { 'author.name=author2'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name' => 'author2')
+        end
+        context 'for a has_many association' do
+          let(:filters_string) { 'taggings.label=primary' }
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:taggings).where('active_taggings.label' => 'primary')
+        end
+        context 'for a has_many through association' do
+          let(:filters_string) { 'tags.name=blue' }
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:tags).where('active_tags.name' => 'blue')
+        end
       end
-      context '!!' do
-        let(:filters_string) { 'author.name!!'}
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name IS NULL')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."name" IS NULL
-          SQL
-      end      
-      context 'including LIKE fuzzy queries' do
-        context 'LIKE' do
-          let(:filters_string) { 'author.name=author*'}
-          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name LIKE "author%"')
+
+      # NOTE: apparently AR when conditions are build with strings in the where clauses (instead of names, etc)
+      # it decides to parenthesize them, even when there's only 1 condition. Hence the silly parentization of
+      # these SQL fragments here (and others)
+      context 'by using all supported operators' do
+        PREF = Praxis::Extensions::AttributeFiltering::ALIAS_TABLE_PREFIX
+        COMMON_SQL_PREFIX = <<~SQL
+              SELECT "active_books".* FROM "active_books"
+              INNER JOIN
+                "active_authors" "#{PREF}/author" ON "#{PREF}/author"."id" = "active_books"."author_id"
+            SQL
+        context '=' do
+          let(:filters_string) { 'author.id=11'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id = 11')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" = 11)
+            SQL
+        end
+        context '= (with array)' do
+          let(:filters_string) { 'author.id=11,22'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id IN (11,22)')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" IN (11,22))
+            SQL
+        end      
+        context '!=' do
+          let(:filters_string) { 'author.id!=11'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id <> 11')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" <> 11)
+            SQL
+        end
+        context '!= (with array)' do
+          let(:filters_string) { 'author.id!=11,888'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id NOT IN (11,888)')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" NOT IN (11,888))
+            SQL
+        end
+        context '>' do
+          let(:filters_string) { 'author.id>1'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id > 1')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" > 1)
+            SQL
+        end
+        context '<' do
+          let(:filters_string) { 'author.id<22'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id < 22')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" < 22)
+            SQL
+        end
+        context '>=' do
+          let(:filters_string) { 'author.id>=22'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id >= 22')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" >= 22)
+            SQL
+        end
+        context '<=' do
+          let(:filters_string) { 'author.id<=22'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id <= 22')
+          it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."id" <= 22)
+            SQL
+        end
+        context '!' do
+          let(:filters_string) { 'author.id!'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id IS NOT NULL')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."name" LIKE 'author%'
-          SQL
+              WHERE ("#{PREF}/author"."id" IS NOT NULL)
+            SQL
         end
-        context 'NOT LIKE' do
-          let(:filters_string) { 'author.name!=foobar*'}
-          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name NOT LIKE "foobar%"')
+        context '!!' do
+          let(:filters_string) { 'author.name!!'}
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name IS NULL')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE "#{PREF}/author"."name" NOT LIKE 'foobar%'
-          SQL
+              WHERE ("#{PREF}/author"."name" IS NULL)
+            SQL
+        end      
+        context 'including LIKE fuzzy queries' do
+          context 'LIKE' do
+            let(:filters_string) { 'author.name=author*'}
+            it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name LIKE "author%"')
+            it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."name" LIKE 'author%')
+            SQL
+          end
+          context 'NOT LIKE' do
+            let(:filters_string) { 'author.name!=foobar*'}
+            it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name NOT LIKE "foobar%"')
+            it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
+              WHERE ("#{PREF}/author"."name" NOT LIKE 'foobar%')
+            SQL
+          end
         end
       end
-    end
 
-    context 'with a field mapping using a proc' do
-      let(:filters_string) { 'name_is_not=Book1' }
-      it_behaves_like 'subject_equivalent_to', ActiveBook.where.not(simple_name: 'Book1')
-    end
+      context 'with a field mapping using a proc' do
+        let(:filters_string) { 'name_is_not=Book1' }
+        it_behaves_like 'subject_equivalent_to', ActiveBook.where.not(simple_name: 'Book1')
+      end
 
-    context 'with a deeply nested chains' do
-      context 'of depth 2' do
-        let(:filters_string) { 'category.books.name=Book2' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(category: :books).where('books_active_categories.simple_name': 'Book2')
+      context 'with a deeply nested chains' do
+        context 'of depth 2' do
+          let(:filters_string) { 'category.books.name=Book2' }
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(category: :books).where('books_active_categories.simple_name': 'Book2')
+        end
+        context 'multiple conditions on a nested relationship' do
+          let(:filters_string) { 'category.books.taggings.tag_id=1&category.books.taggings.label=primary' }
+          it_behaves_like 'subject_equivalent_to', 
+            ActiveBook.joins(category: { books: :taggings }).where('active_taggings.tag_id': 1).where('active_taggings.label': 'primary')
+          it_behaves_like 'subject_matches_sql', <<~SQL
+              SELECT "active_books".* FROM "active_books"
+                INNER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
+                INNER JOIN "active_books" "books_active_categories" ON "books_active_categories"."category_uuid" = "active_categories"."uuid"
+                INNER JOIN "active_taggings" "#{PREF}/category/books/taggings" ON "/category/books/taggings"."book_id" = "books_active_categories"."id"
+                WHERE ("#{PREF}/category/books/taggings"."tag_id" = 1)
+                AND ("#{PREF}/category/books/taggings"."label" = 'primary')
+            SQL
+        end
+        context 'that contain multiple joins to the same table' do
+          let(:filters_string) { 'taggings.tag.taggings.tag_id=1' }
+          it_behaves_like 'subject_equivalent_to', 
+            ActiveBook.joins(taggings: {tag: :taggings}).where('taggings_active_tags.tag_id=1')
+        end
       end
-      context 'multiple conditions on a nested relationship' do
-        let(:filters_string) { 'category.books.taggings.tag_id=1&category.books.taggings.label=primary' }
-        it_behaves_like 'subject_equivalent_to', 
-          ActiveBook.joins(category: { books: :taggings }).where('active_taggings.tag_id': 1).where('active_taggings.label': 'primary')
-        it_behaves_like 'subject_matches_sql', <<~SQL
-            SELECT "active_books".* FROM "active_books"
-              INNER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
-              INNER JOIN "active_books" "books_active_categories" ON "books_active_categories"."category_uuid" = "active_categories"."uuid"
-              INNER JOIN "active_taggings" "#{PREF}/category/books/taggings" ON "/category/books/taggings"."book_id" = "books_active_categories"."id"
-              WHERE ("#{PREF}/category/books/taggings"."tag_id" = 1)
-              AND ("#{PREF}/category/books/taggings"."label" = 'primary')
-          SQL
+
+      context 'by multiple fields' do
+        context 'adds the where clauses for the top model if fields belong to it' do
+          let(:filters_string) { 'category_uuid=deadbeef1&name=Book1' }
+          it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1',  simple_name: 'Book1')
+        end
+        context 'adds multiple where clauses for same nested relationship join (instead of multiple joins with 1 clause each)' do
+          let(:filters_string) { 'taggings.label=primary&taggings.tag_id=2' }
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:taggings).where('active_taggings.label' => 'primary', 'active_taggings.tag_id' => 2)
+        end
       end
-      context 'that contain multiple joins to the same table' do
-        let(:filters_string) { 'taggings.tag.taggings.tag_id=1' }
-        it_behaves_like 'subject_equivalent_to', 
-          ActiveBook.joins(taggings: {tag: :taggings}).where('taggings_active_tags.tag_id=1')
+
+      context 'uses fully qualified names for conditions (disambiguate fields)' do
+        context 'when we have a join table condition that has the same field' do
+          let(:filters_string) { 'name=Book1&category.books.name=Book3' }
+          it_behaves_like 'subject_equivalent_to', ActiveBook.joins(category: :books)
+                                                    .where('simple_name': 'Book1')
+                                                    .where('books_active_categories.simple_name': 'Book3')
+          it_behaves_like 'subject_matches_sql', <<~SQL
+              SELECT "active_books".* FROM "active_books"
+                INNER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
+                INNER JOIN "active_books" "#{PREF}/category/books" ON "#{PREF}/category/books"."category_uuid" = "active_categories"."uuid"    
+              WHERE ("active_books"."simple_name" = 'Book1')
+              AND ("#{PREF}/category/books"."simple_name" = 'Book3')
+            SQL
+        end
+
+        context 'it qualifis them even if there are no joined tables/conditions at all' do
+          let(:filters_string) { 'id=11'}
+          it_behaves_like 'subject_matches_sql', <<~SQL
+            SELECT "active_books".* FROM "active_books"
+              WHERE ("active_books"."id" = 11)
+            SQL
+        end
+
       end
     end
 
-    context 'by multiple fields' do
+    context 'with simple OR conditions' do
       context 'adds the where clauses for the top model if fields belong to it' do
-        let(:filters_string) { 'category_uuid=deadbeef1&name=Book1' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1',  simple_name: 'Book1')
+        let(:filters_string) { 'category_uuid=deadbeef1|name=Book1' }
+        it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1').or(ActiveBook.where(simple_name: 'Book1'))
+      end
+      context 'supports top level parenthesis' do
+        let(:filters_string) { '(category_uuid=deadbeef1|name=Book1)' }
+        it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1').or(ActiveBook.where(simple_name: 'Book1'))
       end
       context 'adds multiple where clauses for same nested relationship join (instead of multiple joins with 1 clause each)' do
-        let(:filters_string) { 'taggings.label=primary&taggings.tag_id=2' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:taggings).where('active_taggings.label' => 'primary', 'active_taggings.tag_id' => 2)
+        let(:filters_string) { 'taggings.label=primary|taggings.tag_id=2' }
+        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:taggings).where('active_taggings.label' => 'primary')
+                                                .or(ActiveBook.joins(:taggings).where('active_taggings.tag_id' => 2))        
       end
     end
 
-    context 'uses fully qualified names for conditions (disambiguate fields)' do
-      context 'when we have a join table condition that has the same field' do
-        COMMON_SQL_PREFIX = <<~SQL
+    context 'with combined AND and OR conditions' do
+      let(:filters_string) { '(category_uuid=deadbeef1|category_uuid=deadbeef2)&(name=Book1|name=Book2)' }
+      it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: 'deadbeef1').or(ActiveBook.where(category_uuid: 'deadbeef2'))
+                                              .and(ActiveBook.where(simple_name: 'Book1').or(ActiveBook.where(simple_name: 'Book2')))
+      it_behaves_like 'subject_matches_sql', <<~SQL
         SELECT "active_books".* FROM "active_books"
-          INNER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
-          INNER JOIN "active_books" "#{PREF}/category/books" ON "#{PREF}/category/books"."category_uuid" = "active_categories"."uuid"    
-        SQL
-        let(:filters_string) { 'name=Book1&category.books.name=Book3' }
-        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(category: :books)
-                                                  .where('simple_name': 'Book1')
-                                                  .where('books_active_categories.simple_name': 'Book3')
-        it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-            WHERE ("#{PREF}/category/books"."simple_name" = 'Book3')
-            AND ("active_books"."simple_name" = 'Book1')
-          SQL
-      end
+          WHERE ("active_books"."category_uuid" = 'deadbeef1' OR "active_books"."category_uuid" = 'deadbeef2')
+          AND ("active_books"."simple_name" = 'Book1' OR "active_books"."simple_name" = 'Book2')
+      SQL
 
-      context 'it qualifis them even if there are no joined tables/conditions at all' do
-        let(:filters_string) { 'id=11'}
+      context 'adds multiple where clauses for same nested relationship join (instead of multiple joins with 1 clause each)' do
+        let(:filters_string) { 'taggings.label=primary|taggings.tag_id=2' }
+        it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:taggings).where('active_taggings.label' => 'primary')
+                                                .or(ActiveBook.joins(:taggings).where('active_taggings.tag_id' => 2))
         it_behaves_like 'subject_matches_sql', <<~SQL
           SELECT "active_books".* FROM "active_books"
-            WHERE "active_books"."id" = 11
-          SQL
+            INNER JOIN "active_taggings" "/taggings" ON "/taggings"."book_id" = "active_books"."id"
+            WHERE ("/taggings"."label" = 'primary' OR "/taggings"."tag_id" = 2)
+        SQL
       end
 
+      context '3-deep AND and OR conditions' do
+        let(:filters_string) { '(category.name=cat2|(taggings.label=primary&tags.name=red))&category_uuid=deadbeef1' }
+        it_behaves_like('subject_equivalent_to', Proc.new do
+          base=ActiveBook.joins(:category,:taggings,:tags)
+
+          and1_or1 = base.where('category.name': 'cat2')
+
+          and1_or2_and1 = base.where('taggings.label': 'primary')
+          and1_or2_and2 = base.where('tags.name': 'red')
+          and1_or2 = and1_or2_and1.and(and1_or2_and2)
+
+          and1 = and1_or1.or(and1_or2)
+          and2=base.where(category_uuid: 'deadbeef1')
+
+          query = and1.and(and2)
+        end)
+
+        it_behaves_like 'subject_matches_sql', <<~SQL
+        SELECT "active_books".* FROM "active_books" 
+          INNER JOIN "active_categories" "/category" ON "/category"."uuid" = "active_books"."category_uuid" 
+          INNER JOIN "active_taggings" "/taggings" ON "/taggings"."book_id" = "active_books"."id" 
+          INNER JOIN "active_taggings" "taggings_active_books_join" ON "taggings_active_books_join"."book_id" = "active_books"."id" 
+          INNER JOIN "active_tags" "/tags" ON "/tags"."id" = "taggings_active_books_join"."tag_id"         
+          WHERE ("/category"."name" = 'cat2' OR ("/taggings"."label" = 'primary') AND ("/tags"."name" = 'red')) AND ("active_books"."category_uuid" = 'deadbeef1')
+        SQL
+      end
     end
 
     context 'ActiveRecord continues to work as expected (with our patches)' do