praxis 2.0.pre.9 → 2.0.pre.10

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

@@ -220,16 +220,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/field_expansion_spec.rb

@@ -24,8 +24,7 @@ describe Praxis::Extensions::FieldExpansion do
 
   let(:request_params) do
     double('params',
-      fields: Praxis::Extensions::FieldSelection::FieldSelector.for(Person).load(fields),
-      view: view
+      fields: Praxis::Extensions::FieldSelection::FieldSelector.for(Person).load(fields)
     )
   end
 
@@ -33,7 +32,6 @@ describe Praxis::Extensions::FieldExpansion do
   let(:media_type) { Person }
 
   let(:fields) { nil }
-  let(:view) { nil }
 
   let(:test_attributes) {  }
   let(:test_params) { double('test_params', attributes: test_attributes) }
@@ -43,43 +41,26 @@ describe Praxis::Extensions::FieldExpansion do
   context '#expanded_fields' do
 
     context 'with fields and view params defined' do
-      let(:test_attributes) { {view: true, fields: true}  }
+      let(:test_attributes) { {} }
 
-      context 'and no fields provided' do
+      context 'with no fields provided' do
         it 'returns the fields for the default view' do
           expect(expansion).to eq({id: true, name: true})
         end
-
-        pending 'and a view'
       end
 
       context 'with a set of fields provided' do
         let(:fields) { 'id,name,owner{name}' }
-        it 'returns the subset of fields for the default view' do
+        it 'returns the subset of fields' do
           expected = {id: true, name: true }
           expect(expansion).to eq expected
         end
-
-        pending 'and a view'
       end
     end
 
-    context 'with only a view param defined' do
-      let(:test_attributes) { {view: true}  }
-
-      it 'returns the fields for the default view' do
-        expect(expansion).to eq({id: true, name: true})
-      end
-
-      pending 'and a view'
-    end
-
-
     context 'with an action with no params' do
       let(:test_params) { nil }
-      let(:fields){ nil }
-      let(:view){ nil }
-      it 'ignores incoming parameters and expands for the default view' do
+      it 'ignores incoming parameters and expands for the default fieldset' do
         expect(expansion).to eq({id: true, name: true})
       end
     end

data/spec/praxis/field_expander_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Praxis::FieldExpander do
+  let(:field_expander) { Praxis::FieldExpander.new }
+  let(:expanded_person_default_fieldset) do
+    # The only ones that are not already leaves is the full name, which can expand to first, last
+    PersonBlueprint.default_fieldset.merge!(full_name: {first: true, last: true})
+  end
+  let(:expanded_address_default_fieldset) do
+    # AddressBlueprint' default fieldset already has all attributes as leaves
+    AddressBlueprint.default_fieldset
+  end
+
+  context 'expanding attributes of a PersonBlueprint blueprint' do
+    it 'with fields=true, expands all fields on the default fieldset' do
+      expect(field_expander.expand(PersonBlueprint, true)).to eq(expanded_person_default_fieldset)
+    end
+
+    it 'expands for a subset of the direct fields' do
+      expect(field_expander.expand(PersonBlueprint, name: true)).to eq(name: true)
+    end
+
+    it 'raises when trying to expand fields that do not exist in the type' do
+      expect do
+        field_expander.expand(PersonBlueprint, name: true, foobar: true)
+      end.to raise_error(/.*:foobar.*do not exist in PersonBlueprint/)
+    end
+
+    context 'given inlined struct attribtue' do
+      it 'expands for a sub-struct' do
+        expect(field_expander.expand(PersonBlueprint, parents: true)).to eq(parents: { mother: true, father: true })
+      end
+
+      it 'expands for a subset of a substruct' do
+        expect(field_expander.expand(PersonBlueprint, parents: { mother: true })).to eq(parents: { mother: true })
+      end
+    end
+
+    context 'given a non-inlined struct sub attribute' do
+      it 'expands a specific subattribute of a struct' do
+        expect(field_expander.expand(PersonBlueprint, full_name: { first: true })).to eq(full_name: { first: true })
+      end
+
+      it 'fully expands collections properly by simply listing subfields' do
+        expect(field_expander.expand(PersonBlueprint, prior_addresses: true)).to eq(prior_addresses: expanded_address_default_fieldset)
+      end
+    end
+
+    context 'given a attribute that is also a blueprint' do
+      it 'expands to default fieldset for an attribute that is also blueprint' do
+        expect(field_expander.expand(PersonBlueprint, address: true)).to eq(address: expanded_address_default_fieldset)
+      end
+
+      it 'expands to default fieldset for a subset of fields of an attribute that is a blueprint' do
+        expect(field_expander.expand(PersonBlueprint, address: { resident: true })).to eq(address: { resident: expanded_person_default_fieldset })
+      end
+    end
+
+    context 'collection attributes' do
+      it 'expands subfields by simply listing subfields the same as structs/blueprints' do
+        expect(field_expander.expand(PersonBlueprint, prior_addresses: { state: true })).to eq(prior_addresses: { state: true })
+      end
+    end
+  end
+
+  it 'expands for for a primitive type' do
+    expect(field_expander.expand(String)).to eq(true)
+  end
+
+  it 'expands for an Attributor::Model' do
+    expect(field_expander.expand(FullName)).to eq(first: true, last: true)
+  end
+
+  it 'expands for a Blueprint' do
+    expect(field_expander.expand(PersonBlueprint, parents: true)).to eq(parents: { father: true, mother: true })
+  end
+
+  it 'expands for an Attributor::Collection of an Attrbutor::Model' do
+    expect(field_expander.expand(Attributor::Collection.of(FullName))).to eq(first: true, last: true)
+  end
+
+  it 'expands for an Attributor::Collection of a Blueprint' do
+    expected = { name: true, resident: { full_name: { first: true, last: true } } }
+    expect(field_expander.expand(Attributor::Collection.of(AddressBlueprint), name: true, resident: { full_name: true })).to eq(expected)
+  end
+
+  it 'also expands array-wrapped field hashes for collections' do
+    expected = { name: true, resident: { full_name: { first: true, last: true } } }
+    expect(field_expander.expand(Attributor::Collection.of(AddressBlueprint), name: true, resident: { full_name: true })).to eq(expected)
+  end
+
+  it 'expands for an Attributor::Collection of a primitive type' do
+    expect(field_expander.expand(Attributor::Collection.of(String))).to eq(true)
+  end
+
+  context 'expanding a two-dimensional collection' do
+    it 'expands the fields discarding the collection nexting nesting' do
+      matrix_type =  Attributor::Collection.of(Attributor::Collection.of(FullName))
+      expect(field_expander.expand(matrix_type)).to eq(first: true, last: true)
+    end
+  end
+
+  context 'circular expansions' do
+    it 'preserve field object identity for circular references' do
+      result = field_expander.expand(PersonBlueprint, address: {resident: true}, work_address: {resident: true})
+      expect(result[:address][:resident]).to be(result[:work_address][:resident])
+    end
+
+    context 'with collections of Blueprints' do
+      it 'still preserves object identity' do
+        result = field_expander.expand(PersonBlueprint, address: {resident: true}, prior_addresses: {resident: true})
+        expect(result[:address][:resident]).to be(result[:prior_addresses][:resident])
+      end
+    end
+  end
+
+  it 'optimizes duplicate field expansions' do
+    expect(field_expander.expand(FullName, true)).to be(field_expander.expand(FullName, true))
+  end
+
+  context 'expanding hash attributes' do
+    let(:type) do
+      Class.new(Attributor::Model) do
+        attributes do
+          attribute :name, String
+          attribute :simple_hash, Hash
+          attribute :keyed_hash, Hash do
+            key :foo, String
+            key :bar, String
+          end
+          attribute :some_struct do
+            attribute :something, String
+          end
+        end
+      end
+    end
+
+    it 'expands' do
+      expected = {
+        name: true,
+        simple_hash: true,
+        keyed_hash: { foo: true, bar: true },
+        some_struct: { something: true }
+      }
+      expect(field_expander.expand(type, true)).to eq(expected)
+    end
+  end
+end