praxis 2.0.pre.2 → 2.0.pre.7

data/lib/praxis/types/multipart_array.rb

@@ -153,6 +153,68 @@ module Praxis
         example
       end
 
+      def self.json_schema_type
+        :object
+      end
+
+      # Multipart request bodies are special in OPEN API
+      # schema:            # Request payload
+      # type: object
+      # properties:      # Request parts
+      #   id:            # Part 1 (string value)
+      #     type: string
+      #     format: uuid
+      #   address:       # Part2 (object)
+      #     type: object
+      #     properties:
+      #       street:
+      #         type: string
+      #       city:
+      #         type: string
+      #   profileImage:  # Part 3 (an image)
+      #     type: string
+      #     format: binary
+      # 
+      # NOTE: not sure if this 
+      def self.as_openapi_request_body( attribute_options: {} )
+        hash = { type: json_schema_type }
+        opts = self.options.merge( attribute_options )
+        hash[:description] = opts[:description] if opts[:description]
+        hash[:default] = opts[:default] if opts[:default]
+
+        unless self.attributes.empty?
+          props = {}
+          encoding = {}
+          self.attributes.each do |part_name, part_attribute|
+            part_example = part_attribute.example
+            key_to_use = part_name.is_a?(Regexp) ? part_name.source : part_name
+            
+            part_info = {}
+            if (payload_attribute = part_attribute.options[:payload_attribute])
+              props[key_to_use] = payload_attribute.as_json_schema(example: part_example.payload)
+            end
+            #{
+            # contentType: 'fff',
+            # headers: {
+            #   custom1: 'safd'
+            # }
+            if (headers_attribute = part_attribute.options[:headers_attribute])
+              # Does this 'Content-Type' string check work?...can it be a symbol? what does it mean anyway?
+              encoding[key_to_use][:contentType] = headers_attribute['Content-Type'] if headers_attribute['Content-Type']
+              # TODO?rethink? ...is this correct?: att a 'headers' key with some header schemas if this part have some
+              encoding[key_to_use]['headers'] = headers_attribute.as_json_schema(example: part_example.headers)
+            end
+          end
+
+          hash[:properties] = props
+          hash[:encoding] = encoding unless encoding.empty?
+        end
+        hash
+      end
+
+      def self.as_json_schema( shallow: false, example: nil, attribute_options: {} )
+        as_openapi_request_body(attribute_options: attribute_options)
+      end
 
       def self.describe(shallow=true, example: nil)
         type_name = Attributor.type_name(self)

data/lib/praxis/validation_handler.rb

@@ -3,8 +3,7 @@ module Praxis
 
     # Should return the Response to send back
     def handle!(summary:, request:, stage:, errors: nil, exception: nil, **opts)
-      documentation = Docs::LinkBuilder.instance.for_request request
-      Responses::ValidationError.new(summary: summary, errors: errors, exception: exception, documentation: documentation, **opts)
+      Responses::ValidationError.new(summary: summary, errors: errors, exception: exception, **opts)
     end
 
   end

data/lib/praxis/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  VERSION = '2.0.pre.2'
+  VERSION = '2.0.pre.7'
 end

data/praxis.gemspec

@@ -24,14 +24,14 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'mustermann', '>=1.1', '<=2'
   spec.add_dependency 'activesupport', '>= 3'
   spec.add_dependency 'mime', '~> 0'
-  spec.add_dependency 'praxis-blueprints', '>= 3.4'
-  spec.add_dependency 'attributor', '>= 5.4'
+  spec.add_dependency 'praxis-blueprints', '>= 3.5'
+  spec.add_dependency 'attributor', '>= 5.5'
   spec.add_dependency 'thor'
   spec.add_dependency 'terminal-table', '~> 1.4'
 
   spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake', '~> 0.9'
-  spec.add_development_dependency 'rake-notes', '~> 0'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
+  
   if RUBY_PLATFORM !~ /java/
     spec.add_development_dependency 'pry'
     spec.add_development_dependency 'pry-byebug'
@@ -49,6 +49,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rack-test', '~> 0'
   spec.add_development_dependency 'simplecov', '~> 0'
   spec.add_development_dependency 'fuubar', '~> 2'
-  spec.add_development_dependency 'yard', ">= 0.9.20"
   spec.add_development_dependency 'coveralls'
+  # Just for the query selector extensions etc...
+  spec.add_development_dependency 'sequel', '~> 5'
+  spec.add_development_dependency 'activerecord', '> 4'
 end

data/spec/functional_spec.rb

@@ -331,12 +331,15 @@ describe 'Functional specs' do
   end
 
   context 'wildcard verb routing' do
+    let(:content_type){ 'application/json' }
     it 'can terminate instances with POST' do
-      post '/api/clouds/23/instances/1/terminate?api_version=1.0', '', 'global_session' => session
+      post '/api/clouds/23/instances/1/terminate?api_version=1.0', nil, 'CONTENT_TYPE' => content_type, 'global_session' => session
+      puts last_response.body
+      #binding.pry
       expect(last_response.status).to eq(200)
     end
     it 'can terminate instances with DELETE' do
-      post '/api/clouds/23/instances/1/terminate?api_version=1.0', '', 'global_session' => session
+      post '/api/clouds/23/instances/1/terminate?api_version=1.0', nil, 'CONTENT_TYPE' => content_type, 'global_session' => session
       expect(last_response.status).to eq(200)
     end
 
@@ -355,7 +358,7 @@ describe 'Functional specs' do
 
   context 'auth_plugin' do
     it 'can terminate' do
-      post '/api/clouds/23/instances/1/terminate?api_version=1.0', '', 'global_session' => session
+      post '/api/clouds/23/instances/1/terminate?api_version=1.0', nil, 'global_session' => session
       expect(last_response.status).to eq(200)
     end
 
@@ -366,8 +369,8 @@ describe 'Functional specs' do
   end
 
   context 'with mismatch between Content-Type and payload' do
-    let(:body) { '{}' }
-    let(:content_type) { 'application/x-www-form-urlencoded' }
+    let(:body) { 'some-text' }
+    let(:content_type) { 'application/json' }
 
     before do
       post '/api/clouds/1/instances/2/terminate?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
@@ -376,7 +379,7 @@ describe 'Functional specs' do
     it 'returns a useful error message' do
       body = JSON.parse(last_response.body)
       expect(body['name']).to eq('ValidationError')
-      expect(body['summary']).to match("Error loading payload. Used Content-Type: 'application/x-www-form-urlencoded'")
+      expect(body['summary']).to match("Error loading payload. Used Content-Type: 'application/json'")
       expect(body['errors']).to_not be_empty
     end
   end

data/spec/praxis/action_definition_spec.rb

@@ -115,7 +115,7 @@ describe Praxis::ActionDefinition do
     end
 
     its('params.attributes.keys') { should eq [:inherited, :app_name, :name, :one]}
-    its('routes.first.path.to_s') { should eq '/api/foobars/hello_world/test_trait/:app_name/:one' }
+    its('route.path.to_s') { should eq '/api/foobars/hello_world/test_trait/:app_name/:one' }
     its(:traits) { should eq [:test] }
 
     it 'is reflected in the describe output' do
@@ -231,7 +231,7 @@ describe Praxis::ActionDefinition do
       let(:parent_param) { ApiResources::Volumes.actions[:show].params.attributes[:id] }
 
       it 'has the right path' do
-        expect(action.primary_route.path.to_s).to eq '/api/clouds/:cloud_id/volumes/:volume_id/snapshots/:id'
+        expect(action.route.path.to_s).to eq '/api/clouds/:cloud_id/volumes/:volume_id/snapshots/:id'
       end
 
       its('params.attributes'){ should have_key(:cloud_id) }
@@ -281,22 +281,10 @@ describe Praxis::ActionDefinition do
     subject(:action) { resource_definition.actions[:show] }
 
     it 'works' do
-      expansion = action.primary_route.path.expand(cloud_id:'232', id: '2')
+      expansion = action.route.path.expand(cloud_id:232, id: 2)
       expect(expansion).to eq "/api/clouds/232/instances/2"
     end
 
-    context '#primary_route' do
-      it 'is the first-defined route' do
-        expect(action.primary_route).to be(action.routes.first)
-      end
-    end
-
-    context '#named_routes' do
-      subject(:named_routes) { action.named_routes }
-
-      its([:alternate]) { should be(action.routes[1]) }
-    end
-
   end
 
   context 'with nodoc!' do
@@ -339,7 +327,7 @@ describe Praxis::ActionDefinition do
       allow(Praxis::ApiDefinition).to receive(:instance).and_return(non_singleton_api)
     end
 
-    its('routes.first.path.to_s') { should eq '/apps/:app_name/foobars/hello_world/:one' }
+    its('route.path.to_s') { should eq '/apps/:app_name/foobars/hello_world/:one' }
     its('params.attributes.keys') { should match_array [:inherited, :app_name, :one]}
 
     context 'where the action overrides a base_param' do

data/spec/praxis/api_general_info_spec.rb

@@ -17,8 +17,8 @@ describe Praxis::ApiGeneralInfo do
       endpoint 'api.example.com'
       base_path "/base"
 
-      consumes 'xml', 'x-www-form-urlencoded'
-      produces 'json', 'x-www-form-urlencoded'
+      consumes 'json'
+      produces 'json'
 
       base_params do
         attribute :name, String
@@ -40,8 +40,8 @@ describe Praxis::ApiGeneralInfo do
     end
 
     its(:name) { should eq 'Name' }
-    its(:consumes) { should eq ['xml', 'x-www-form-urlencoded']}
-    its(:produces) { should eq ['json', 'x-www-form-urlencoded']}
+    its(:consumes) { should eq ['json']}
+    its(:produces) { should eq ['json']}
   end
 
   context '.describe' do
@@ -59,8 +59,8 @@ describe Praxis::ApiGeneralInfo do
     its([:base_params, :name, :type, :name]) { should eq 'String' }
     its([:version_with]) { should eq([:header, :params]) }
     its([:endpoint]) { should eq 'api.example.com' }
-    its([:consumes]) { should eq ['xml', 'x-www-form-urlencoded'] }
-    its([:produces]) { should eq ['json', 'x-www-form-urlencoded'] }
+    its([:consumes]) { should eq ['json'] }
+    its([:produces]) { should eq ['json'] }
   end
 
   context 'base_path with versioning' do

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

@@ -0,0 +1,304 @@
+require 'spec_helper'
+
+require_relative '../support/spec_resources_active_model.rb'
+require 'praxis/extensions/attribute_filtering'
+require 'praxis/extensions/attribute_filtering/active_record_filter_query_builder'
+
+describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder do
+  let(:root_resource) { ActiveBookResource }
+  let(:filters_map) { root_resource.instance_variable_get(:@_filters_map)}
+  let(:base_model) { root_resource.model }
+  let(:base_query) { base_model }
+  let(:instance) { described_class.new(query: base_query, model: base_model, filters_map: filters_map) }
+
+  shared_examples 'subject_equivalent_to' do |expected_result|
+    it do
+      loaded_ids = subject.all.map(&:id).sort
+      expected_ids = expected_result.all.map(&:id).sort
+      expect(loaded_ids).to_not be_empty
+      expect(loaded_ids).to eq(expected_ids)
+    end
+  end
+
+  # 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(/[()]/,'')
+      # 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(/[()]/,'')
+      end.join.strip
+      expect(gen_sql).to eq(exp)
+    end
+  end
+
+  context 'initialize' do
+    it 'sets the right things to the instance' do
+      instance
+      expect(instance.query).to eq(base_query)
+      expect(instance.model).to eq(base_model)
+      expect(instance.attr_to_column).to eq(filters_map)
+    end
+  end
+  context 'generate' do
+    subject { instance.generate(filters) }
+    let(:filters) { Praxis::Types::FilteringParams.load(filters_string)}
+
+    context 'with no filters' do
+      let(:filters_string) { '' }
+      it 'does not modify the query' do
+        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 '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 '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
+      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%"')
+          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
+
+    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')
+      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 '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 '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
+        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
+
+      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
+
+    context 'ActiveRecord continues to work as expected (with our patches)' do
+      context 'using a deep join with repeated tables' do
+        subject{ ActiveBook.joins(taggings: {tag: :taggings}).where('taggings_active_tags.tag_id=1') }
+        it 'performs query' do
+          expect(subject.to_a).to_not be_empty 
+        end
+        it_behaves_like 'subject_matches_sql', <<~SQL
+          SELECT "active_books".* FROM "active_books"
+            INNER JOIN "active_taggings" ON "active_taggings"."book_id" = "active_books"."id"
+            INNER JOIN "active_tags" ON "active_tags"."id" = "active_taggings"."tag_id"
+            INNER JOIN "active_taggings" "taggings_active_tags" ON "taggings_active_tags"."tag_id" = "active_tags"."id"
+            WHERE (taggings_active_tags.tag_id=1)
+        SQL
+      end
+      context 'a deep join with repeated tables with the root AND the join, along with :through joins as well' do
+        subject!{ ActiveBook.joins(tags: {books: {taggings: :book}}).where('books_active_taggings.simple_name="Book2"') }
+        it 'performs query' do
+          expect(subject.to_a).to_not be_empty 
+        end
+        it_behaves_like 'subject_matches_sql', <<~SQL
+          SELECT "active_books".* FROM "active_books" 
+               INNER JOIN "active_taggings" ON "active_taggings"."book_id" = "active_books"."id"
+               INNER JOIN "active_tags" ON "active_tags"."id" = "active_taggings"."tag_id"
+               INNER JOIN "active_taggings" "taggings_active_tags_join" ON "taggings_active_tags_join"."tag_id" = "active_tags"."id" 
+               INNER JOIN "active_books" "books_active_tags" ON "books_active_tags"."id" = "taggings_active_tags_join"."book_id" 
+               INNER JOIN "active_taggings" "taggings_active_books" ON "taggings_active_books"."book_id" = "books_active_tags"."id" 
+               INNER JOIN "active_books" "books_active_taggings" ON "books_active_taggings"."id" = "taggings_active_books"."book_id"
+               WHERE (books_active_taggings.simple_name="Book2")             
+        SQL
+      end
+    end
+
+    context 'respects scopes' do
+      context 'for a has_many through association' do
+        let(:filters_string) { 'primary_tags.name=blue' }
+        it_behaves_like 'subject_equivalent_to', 
+          ActiveBook.joins(:primary_tags).where('active_tags.name="blue"')
+
+        it 'adds the association scope clause to the join' do
+          inner_join_pieces = subject.to_sql.split('INNER')
+          found = inner_join_pieces.any? do |line|
+            line =~ /\s+JOIN "active_taggings".+ON.+\."label" = 'primary'/
+          end
+          expect(found).to be_truthy
+        end
+        # This is slightly incorrect in AR 6.1+ (since the picked aliases for active_taggings tables vary)
+        # it_behaves_like 'subject_matches_sql', <<~SQL
+        #   SELECT "active_books".* FROM "active_books"
+        #     INNER JOIN "active_taggings" ON "active_taggings"."label" = 'primary'
+        #                 AND "active_taggings"."book_id" = "active_books"."id"
+        #     INNER JOIN "active_tags" "/primary_tags" ON "/primary_tags"."id" = "active_taggings"."tag_id"
+        #     WHERE ("/primary_tags"."name" = 'blue')
+        # SQL
+      end
+    end
+  end
+end