praxis 2.0.pre.6 → 2.0.pre.11

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

@@ -39,7 +39,7 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
       instance
       expect(instance.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
@@ -57,7 +57,20 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
         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
+      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 '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
@@ -220,16 +233,14 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
 
     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
+        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 ("#{PREF}/category/books"."simple_name" = 'Book3')
             AND ("active_books"."simple_name" = 'Book1')
           SQL

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

@@ -30,5 +30,111 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
         ])
       end
     end
+
+    context 'with an associated MediaType' do
+      let(:params_for_post_media_type) do
+        # Note wrap the filter_params (.for) type in an attribute (which then we discard), so it will 
+        # construct it propertly by applying the block. Seems easier than creating the type alone, and 
+        # then manually apply the block
+        Attributor::Attribute.new(described_class.for(Post)) do
+          filter 'id', using: ['=', '!=', '!']
+        end.type
+      end
+
+      context 'with a single value' do
+        let(:str) { 'id=1' }
+        it 'coerces its value to the associated mediatype attribute type' do
+          parsed = params_for_post_media_type.load(str).parsed_array
+          expect(parsed.first).to eq(:name=>:id, :op=>"=", :value=>1)
+          expect(Post.attributes[:id].type.valid_type?(parsed.first[:value])).to be_truthy
+        end
+      end
+
+      context 'with multimatch' do
+        let(:str) { 'id=1,2,3' }
+        it 'coerces ALL csv values to the associated mediatype attribute type' do
+          parsed = params_for_post_media_type.load(str).parsed_array
+          expect(parsed.first).to eq(:name=>:id, :op=>"=", :value=>[1, 2, 3])
+          parsed.first[:value].each do |val|
+            expect(Post.attributes[:id].type.valid_type?(val)).to be_truthy
+          end
+        end
+      end
+
+      context 'with a single value that is null' do
+        let(:str) { 'id!' }
+        it 'properly loads it as null' do
+          parsed = params_for_post_media_type.load(str).parsed_array
+          expect(parsed.first).to eq(:name=>:id, :op=>"!", :value=>nil)
+        end
+      end
+    end
+
+  end
+
+  context '.validate' do
+    let(:filtering_params_type) do
+      # Note wrap the filter_params (.for) type in an attribute (which then we discard), so it will 
+      # construct it propertly by applying the block. Seems easier than creating the type alone, and 
+      # then manually apply the block
+      Attributor::Attribute.new(described_class.for(Post)) do
+        filter 'id', using: ['=', '!=']
+        filter 'title', using: ['=', '!='], fuzzy: true
+        filter 'content', using: ['=', '!=']
+      end.type
+    end
+    let(:loaded_params) { filtering_params_type.load(filters_string) }
+    subject { loaded_params.validate(filters_string) }
+
+    context 'errors' do
+      context 'given attributes that do not exist in the type' do
+        let(:filters_string) { 'NotAnExistingAttribute=Foobar*'}
+        it 'raises an error' do
+          expect{subject}.to raise_error(/NotAnExistingAttribute.*does not exist/)
+        end
+      end
+
+      context 'given unallowed attributes' do
+        let(:filters_string) { 'href=Foobar*'}
+        it 'raises an error' do
+          expect(subject).to_not be_empty
+          matches_error = subject.any? {|err| err =~ /Filtering by href is not allowed/}
+          expect(matches_error).to be_truthy
+        end
+      end
+
+      context 'given unallowed operator' do
+        let(:filters_string) { 'title>Foobar*'}
+        it 'raises an error' do
+          expect(subject).to_not be_empty
+          expect(subject.first).to match(/Operator > not allowed for filter title/)
+        end
+      end
+    end
+    context 'fuzzy matches' do
+      context 'when allowed' do
+        context 'given a fuzzy string' do
+          let(:filters_string) { 'title=IAmAString*'}
+          it 'validates properly' do
+            expect(subject).to be_empty
+          end
+        end
+      end
+      context 'when NOT allowed' do
+        context 'given a fuzzy string' do
+          let(:filters_string) { 'content=IAmAString*'}
+          it 'errors out' do
+            expect(subject).to_not be_empty
+            expect(subject.first).to match(/Fuzzy matching for content is not allowed/)
+          end
+        end
+        context 'given a non-fuzzy string' do
+          let(:filters_string) { 'content=IAmAString'}
+          it 'validates properly' do
+            expect(subject).to be_empty
+          end
+        end
+      end
+    end
   end
 end