praxis 0.15.0 → 0.16.0

data/spec/praxis/action_definition_spec.rb

@@ -11,7 +11,7 @@ describe Praxis::ActionDefinition do
 
       media_type 'application/json'
       version '1.0'
-      routing { prefix '/api/hello_world' }
+      prefix '/api/hello_world'
       action_defaults do
         payload { attribute :inherited, String }
         headers { header "Inherited", String }
@@ -61,6 +61,44 @@ describe Praxis::ActionDefinition do
     it 'has some tests after we stop using ApiDefinition.instance'
   end
 
+  describe 'when a trait is used' do
+    subject(:action) do
+      Praxis::ActionDefinition.new(:bar, resource_definition) do
+        trait :test
+        routing { get '/:one' }
+        params  { attribute :one, String }
+      end
+    end
+
+    let(:trait) do
+      Praxis::Trait.new do
+        routing do
+          prefix '/test_trait/:app_name'
+        end
+
+        params do
+          attribute :app_name, String
+          attribute :name, String
+        end
+
+      end
+    end
+    let(:traits) { {test: trait} }
+
+    before do
+      allow(Praxis::ApiDefinition.instance).to receive(:traits).and_return(traits)
+    end
+
+    its('params.attributes.keys') { should eq [:inherited, :app_name, :name, :one]}
+    its('routes.first.path.to_s') { should eq '/api/hello_world/test_trait/:app_name/:one' }
+    its(:traits) { should eq [:test] }
+
+    it 'is reflected in the describe output' do
+      expect(action.describe[:traits]).to eq [:test]
+    end
+
+  end
+
   describe '#params' do
     it 'merges in more params' do
       subject.params do
@@ -98,9 +136,8 @@ describe Praxis::ActionDefinition do
         header "more"
       end
 
-      expect(subject.headers.attributes.keys).to match_array([
-                                                               "X_REQUESTED_WITH", "Inherited", "more"
-      ])
+      expected_array = ["X_REQUESTED_WITH", "Inherited", "more"]
+      expect(subject.headers.attributes.keys).to match_array(expected_array)
     end
   end
 
@@ -153,7 +190,7 @@ describe Praxis::ActionDefinition do
 
   context 'with nodoc!' do
     before do
-      action.nodoc!      
+      action.nodoc!
     end
 
     it 'has :doc_visibility set in metadata' do
@@ -165,4 +202,69 @@ describe Praxis::ActionDefinition do
     end
 
   end
+
+  context 'with a base_path and base_params on ApiDefinition' do
+    # Without getting a fresh new ApiDefinition it is very difficult to test stuff using the Singleton
+    # So for some tests we're gonna create a new instance and work with it to avoid the singleton issues
+    let(:non_singleton_api) do
+      api_def=Praxis::ApiDefinition.__send__(:new)
+      api_def.instance_eval do |api|
+
+        api.info do
+          base_path '/apps/:app_name'
+        end
+
+        api.info '1.0' do
+          base_params do
+            attribute :app_name, String
+          end
+        end
+
+      end
+      api_def
+    end
+
+    before do
+      allow(Praxis::ApiDefinition).to receive(:instance).and_return(non_singleton_api)
+    end
+
+    its('routes.first.path.to_s') { should eq '/apps/:app_name/api/hello_world/:one' }
+    its('params.attributes.keys') { should eq [:inherited, :app_name, :one]}
+
+    context 'where the action overrides a base_param' do
+
+      let(:resource_definition) do
+        Class.new do
+          include Praxis::ResourceDefinition
+
+          def self.name
+            'FooBar'
+          end
+          version '1.0'
+          prefix '/api/hello_world'
+          action_defaults do
+            payload { attribute :inherited, String }
+            headers { header "Inherited", String }
+          end
+        end
+      end
+
+      let(:action) do
+        Praxis::ActionDefinition.new(:foo, resource_definition) do
+          routing { get '' }
+          params  { attribute :app_name, Integer }
+        end
+      end
+
+      subject(:attributes) { action.params.attributes }
+
+      its(:keys)  { should eq [:app_name]}
+
+      it 'overrides the base param' do
+        expect(attributes[:app_name].type).to eq(Attributor::Integer)
+      end
+
+    end
+
+  end
 end

data/spec/praxis/api_definition_spec.rb

@@ -1,43 +1,54 @@
 require 'spec_helper'
 
 describe Praxis::ApiDefinition do
-  
-  subject(:api){  Praxis::ApiDefinition.instance }  
-  
+
+  subject(:api){  Praxis::ApiDefinition.instance }
+
   # Without getting a fresh new ApiDefinition it is very difficult to test stuff using the Singleton
   # So for some tests we're gonna create a new instance and work with it to avoid the singleton issues
   let(:non_singleton_api) do
     api_def=Praxis::ApiDefinition.__send__(:new)
     api_def.instance_eval do |api|
-      api.response_template :template1, &Proc.new {} 
-      api.trait :trait1, &Proc.new {} 
+      api.response_template :template1, &Proc.new {}
+      api.trait :trait1, &Proc.new {}
+      api.trait :trait_2 do
+        description 'the second testing trait'
+      end
+
+      api.info '1.0' do
+        base_path '/apps/:app_name'
+        base_params do
+          attribute :app_name, String
+        end
+      end
     end
     api_def
   end
-  
+
   let(:info_block) do
     Proc.new do
       name "Name"
       title "Title"
     end
-  end 
-  
+  end
+
   context 'singleton' do
     it 'should be a Singleton' do
       expect(Praxis::ApiDefinition.ancestors).to include( Singleton )
       expect(subject).to eq(Praxis::ApiDefinition.instance )
     end
-    
+
     it 'has the :ok and :created response templates registered' do
       expect(api.responses.keys).to include(:ok)
       expect(api.responses.keys).to include(:created)
-    end 
+    end
   end
-  
+
+
   context '.response_template' do
     let(:response_template){ Proc.new {} }
     let(:api){ non_singleton_api }
-    
+
     it 'has the defined template1 response_template' do
       expect(api.responses.keys).to include(:template1)
       expect(api.response(:template1)).to be_kind_of(Praxis::ResponseTemplate)
@@ -48,7 +59,7 @@ describe Praxis::ApiDefinition do
       expect(api.response(:foobar)).to be_kind_of(Praxis::ResponseTemplate)
     end
   end
-  
+
   context '.response' do
     let(:api){ non_singleton_api }
 
@@ -56,32 +67,39 @@ describe Praxis::ApiDefinition do
       expect(api.response(:template1)).to be_kind_of(Praxis::ResponseTemplate)
     end
   end
-  
+
   context '.trait' do
     let(:api){ non_singleton_api }
-    
+
     let(:trait2){ Proc.new{} }
+
     it 'has the defined trait1 ' do
       expect(api.traits.keys).to include(:trait1)
-      expect(api.traits[:trait1]).to be_kind_of(Proc)
+      expect(api.traits[:trait1]).to be_kind_of(Praxis::Trait)
     end
-    
-    it 'saves it verbatim' do
-      api.trait :trait2, &trait2
-      expect(api.traits[:trait2]).to be(trait2)
-    end
-    
+
     it 'complains trying to register traits with same name' do
       api.trait :trait2, &trait2
-      expect{ 
+      expect{
         api.trait :trait2, &trait2
       }.to raise_error(Praxis::Exceptions::InvalidTrait, /Overwriting a previous trait with the same name/)
     end
   end
-  
+
   context '.info' do
-    
+
     let(:api){ non_singleton_api }
+    subject(:info) { api.info('1.0') }
+
+    context '.base_path' do
+      its(:base_path) { should eq '/apps/:app_name'}
+    end
+
+    context '.base_params' do
+      subject(:base_params) { info.base_params }
+      it { should be_kind_of(Attributor::Attribute) }
+      its(:attributes) { should include :app_name }
+    end
 
     context 'with a version' do
       it 'saves the data into the correct version hash' do
@@ -89,36 +107,39 @@ describe Praxis::ApiDefinition do
         api.info("9.0", &info_block)
         expect(api.infos.keys).to include("9.0")
       end
-      it 'immediate invokes the block' do
-        expect(api.infos["9.0"]).to receive(:instance_eval)      
-        api.info("9.0", &info_block)
-      end
-    end    
+    end
+
     context 'without a version' do
-      it 'saves it into nil if no version is passed' do
+      it 'saves it into global_info' do
         expect(api.infos.keys).to_not include(nil)
         api.info do
           description "Global Description"
         end
-        expect(api.infos.keys).to include(nil)
+        expect(api.infos.keys).to_not include(nil)
+        expect(api.global_info.description).to eq 'Global Description'
       end
     end
   end
-  
+
   context '.describe' do
     subject(:output){ api.describe }
 
     context 'using the spec_app definitions' do
       subject(:version_output){ output["1.0"][:info] }
-      it 'saves the data into the correct version hash' do
-        expect(api.infos.keys).to include(nil)
-        expect(api.infos.keys).to include("1.0")
-      end
 
+      context 'for the global_info data' do
+        subject(:info) { output[:global][:info] }
+        it { should include(:name, :title, :description) }
+        its([:name]) { should eq 'Spec App' }
+        its([:title]) { should eq 'A simple App to do some simple integration testing' }
+        its([:description]) { should eq 'This example API should really be replaced by a set of more full-fledged example apps in the future' }
+      end
+      
       it 'outputs data for 1.0 info' do
         expect(output.keys).to include("1.0")
         expect(output["1.0"]).to include(:info)
       end
+
       it 'describes 1.0 Api info properly' do
         info = output["1.0"][:info]
         expect(info).to include(:schema_version, :name, :title, :description, :base_path)
@@ -129,21 +150,23 @@ describe Praxis::ApiDefinition do
         expect(info[:base_path]).to eq("/")
       end
     end
-    
+
     context 'using a non-singleton object' do
       let(:api){ non_singleton_api }
-            
+
       before do
         api.info("9.0", &info_block)
         api.info do
           description "Global Description"
         end
       end
-      its(:keys){ should include("9.0") }  
-      
+      its(:keys) { should include("9.0") }
+      its(:keys) { should include :traits }
+      its([:traits, :trait_2]) { should eq api.traits[:trait_2].describe }
+
       context 'for v9.0 info' do
         subject(:v9_info){ output["9.0"][:info] }
-        
+
         it 'has the info it was set in the call' do
           expect(v9_info).to include({schema_version: "1.0"})
           expect(v9_info).to include({name: "Name"})
@@ -152,8 +175,8 @@ describe Praxis::ApiDefinition do
         it 'inherited the description from the nil(global) one' do
           expect(v9_info).to include({description: "Global Description"})
         end
-      
+
       end
     end
   end
-end
+end

data/spec/praxis/api_general_info_spec.rb

@@ -1,36 +1,50 @@
 require 'spec_helper'
 
 describe Praxis::ApiGeneralInfo do
-  
+
   subject(:info){ Praxis::ApiGeneralInfo.new }
-  
+
   let(:info_block) do
     Proc.new do
       name "Name"
       title "Title"
       description "Description"
       base_path "/base"
+      base_params do
+        attribute :name, String
+      end
     end
   end
-  
-  context 'DSLs' do
+
+  context 'setting' do
     it 'accepts the appropriate DSLs' do
-      expect{ 
+      expect{
         info.instance_exec &info_block
       }.to_not raise_error
     end
-    
   end
 
+  context 'getting values' do
+    before do
+      info.instance_exec &info_block
+    end
+
+    its(:name) { should eq 'Name' }
+
+  end
   context '.describe' do
-    subject(:output){ info.describe }
-    it 'works' do
+    before do
       info.instance_exec &info_block
-      expect(output).to eq( 
-        {:schema_version=>"1.0", :name=>"Name", :title=>"Title", 
-          :description=>"Description", :base_path=>"/base"
-        })
     end
-    
+
+    subject(:output){ info.describe }
+    its([:schema_version]) {should eq '1.0' }
+    its([:name]) {should eq 'Name' }
+    its([:title]) {should eq 'Title' }
+    its([:description]) {should eq 'Description' }
+    its([:base_path]) {should eq '/base' }
+    its([:base_params]) { should have_key :name }
+    its([:base_params, :name, :type, :name]) { should eq 'String' }
+
   end
-end
+end

data/spec/praxis/media_type_spec.rb

@@ -9,8 +9,8 @@ describe Praxis::MediaType do
   end
 
   let(:resource) do
-    double('address', 
-      id: 1, 
+    double('address',
+      id: 1,
       name: 'Home',
       owner: owner_resource,
       manager: manager_resource,
@@ -38,7 +38,7 @@ describe Praxis::MediaType do
   end
 
 
-  
+
   context 'accessor methods' do
     subject(:address_klass) { address.class }
 
@@ -62,7 +62,7 @@ describe Praxis::MediaType do
     end
 
     its(:description) { should be_kind_of(String) }
-    
+
     context 'links' do
       context 'with a custom links attribute' do
         subject(:person) { Person.new(owner_resource) }
@@ -70,7 +70,7 @@ describe Praxis::MediaType do
         its(:links)  { should be_kind_of(Array) }
         its(:links)  { should eq(owner_resource.links) }
       end
-  
+
       context 'using the links DSL' do
         subject(:address) { Address.new(resource) }
         its(:links)  { should be_kind_of(Address::Links) }
@@ -114,7 +114,7 @@ describe Praxis::MediaType do
         let(:snapshots_summary) { volume.snapshots_summary }
         let(:output) { volume.render(:default) }
         subject { links[:snapshots] }
-             
+
         its([:name]) { should eq(snapshots_summary.name) }
         its([:size]) { should eq(snapshots_summary.size) }
         its([:href]) { should eq(snapshots_summary.href) }
@@ -140,6 +140,33 @@ describe Praxis::MediaType do
   end
 
 
+  context 'describing' do
+
+    subject(:described){ Address.describe }
+
+    its(:keys) { should match_array( [:attributes, :description, :family, :id, :identifier, :key, :name, :views] ) }
+    its([:attributes]) { should be_kind_of(::Hash) }
+    its([:description]) { should be_kind_of(::String) }
+    its([:family]) { should be_kind_of(::String) }
+    its([:id]) { should be_kind_of(::String) }
+    its([:name]) { should be_kind_of(::String) }
+    its([:identifier]) { should be_kind_of(::String) }
+    its([:key]) { should be_kind_of(::Hash) }
+    its([:views]) { should be_kind_of(::Hash) }
+
+    its([:description]) { should eq(Address.description) }
+    its([:family]) { should eq(Address.family) }
+    its([:id]) { should eq(Address.id) }
+    its([:name]) { should eq(Address.name) }
+    its([:identifier]) { should eq(Address.identifier.to_s) }
+    it 'should include the defined views' do
+      expect( subject[:views].keys ).to match( [:default, :master] )
+    end
+    it 'should include the defined attributes' do
+      expect( subject[:attributes].keys ).to match( [:id, :name, :owner, :custodian, :residents, :residents_summary, :links] )
+    end
+  end
+
   context 'using blueprint caching' do
     it 'has specs'
   end