praxis 0.13.0 → 0.14.0

data/spec/praxis/media_type_spec.rb

@@ -33,7 +33,7 @@ describe Praxis::MediaType do
     its(:description) { should be_kind_of(String) }
     
     context 'links' do
-      context 'with an custom links attribute' do
+      context 'with a custom links attribute' do
         subject(:person) { Person.new(owner_resource) }
 
         its(:links)  { should be_kind_of(Array) }
@@ -62,15 +62,15 @@ describe Praxis::MediaType do
       its([:owner]) { should eq(Person.dump(owner_resource, view: :link)) }
       its([:super]) { should eq(Person.dump(manager_resource, view: :link)) }
 
-      context 'for a collection' do
+      context 'for a collection summary' do
         let(:volume) { Volume.example }
-        let(:snapshots) { volume.snapshots }
+        let(:snapshots_summary) { volume.snapshots_summary }
         let(:output) { volume.render(:default) }
         subject { links[:snapshots] }
              
-        its([:name]) { should eq(snapshots.name) }
-        its([:size]) { should eq(snapshots.size) }
-        its([:href]) { should eq(snapshots.href) }
+        its([:name]) { should eq(snapshots_summary.name) }
+        its([:size]) { should eq(snapshots_summary.size) }
+        its([:href]) { should eq(snapshots_summary.href) }
       end
     end
 

data/spec/praxis/request_stage_spec.rb

@@ -50,6 +50,13 @@ describe Praxis::RequestStages::RequestStage do
   context 'execute_with_around' do
   end
 
+  context '#setup!' do
+    it 'sets up the deferred callbacks' do
+      expect(stage).to receive(:setup_deferred_callbacks!).once
+      stage.setup!
+    end
+  end
+
   context "#execute" do
     before do
       stage.stages.push(substage_1, substage_2, substage_3)
@@ -107,8 +114,6 @@ describe Praxis::RequestStages::RequestStage do
       end
 
       it "sets up and executes callbacks" do
-        expect(stage).to receive(:setup!)
-        expect(stage).to receive(:setup_deferred_callbacks!)
         expect(stage).to receive(:execute)
         expect(stage).to receive(:execute_callbacks).once.with(before_callbacks)
         expect(stage).to receive(:execute_callbacks).once.with(after_callbacks)

data/spec/praxis/request_stages_validate_spec.rb

@@ -9,14 +9,19 @@ describe Praxis::RequestStages::Validate do
 
   let(:action) { controller.definition.actions[:show] }
 
+  let(:env) do
+    e = Rack::MockRequest.env_for('/instances/1?cloud_id=1&api_version=1.0')
+    e['rack.input'] = StringIO.new('something=given')
+    e['HTTP_VERSION'] = 'HTTP/1.1'
+    e['HTTP_HOST'] = 'rightscale'
+    e
+  end
+
   let(:request) do
-    env = Rack::MockRequest.env_for('/instances/1?cloud_id=1&api_version=1.0')
-    env['rack.input'] = StringIO.new('something=given')
-    env['HTTP_VERSION'] = 'HTTP/1.1'
-    env['HTTP_HOST'] = 'rightscale'
-    request = Praxis::Request.new(env)
-    request.action = action
-    request
+    r = Praxis::Request.new(env)
+    r.route_params = {id: 1}
+    r.action = action
+    r
   end
 
   context 'given a request' do

data/spec/praxis/resource_definition_spec.rb

@@ -34,6 +34,16 @@ describe Praxis::ResourceDefinition do
       expect(index).to be_kind_of(Praxis::ActionDefinition)
       expect(index.description).to eq("index description")
     end
+    
+    it 'complains if action names are not symbols' do
+      expect do
+        Class.new do
+          include Praxis::ResourceDefinition
+          action "foo" do
+          end
+        end
+      end.to raise_error(ArgumentError,/Action names must be defined using symbols/)
+    end
   end
 
 
@@ -113,4 +123,56 @@ describe Praxis::ResourceDefinition do
 
   end
 
+  context '#canonical_path' do
+    context 'setting the action' do
+      it 'reads the specified action' do
+        expect(subject.canonical_path).to eq(subject.actions[:show])
+      end
+      it 'cannot be done if already been defined' do
+        expect{
+          resource_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
+        Class.new do
+          include Praxis::ResourceDefinition
+          action :show do
+          end
+        end
+      end
+      it 'defaults to the :show action' do
+        expect(subject.canonical_path).to eq(subject.actions[:show])        
+      end
+    end
+    context 'with an undefined action' do
+      subject(:resource_definition) do
+        Class.new do
+          include Praxis::ResourceDefinition
+          canonical_path :non_existent
+        end
+      end
+      it 'raises an error' do
+        expect{
+          subject.canonical_path
+        }.to raise_error(/Action 'non_existent' does not exist/)
+      end
+    end
+  end
+
+  context '#to_href' do
+    it 'accesses the path expansion functions of the primary route' do
+      expect(subject.to_href( id: 1)).to eq("/people/1")
+    end
+  end
+  context '#parse_href' do
+    let(:parsed){ resource_definition.parse_href("/people/1") }
+    it 'accesses the path expansion functions of the primary route' do
+      expect(parsed).to have_key(:id)
+    end
+    it 'coerces the types as specified in the resource definition' do
+      expect(parsed[:id]).to be_kind_of(Integer)
+    end
+  end
 end

data/spec/praxis/response_definition_spec.rb

@@ -365,7 +365,16 @@ describe Praxis::ResponseDefinition do
 
           context 'when content type matches the mediatype of the spec' do
             let(:response_headers) { {'Content-Type' => content_type } }
-            it 'should raise error telling you so' do
+            it 'validates successfully' do
+              expect {
+                response_definition.validate_content_type!(response)
+              }.to_not raise_error
+            end
+          end
+
+          context 'when content type includes a parameter' do
+            let(:response_headers) { {'Content-Type' => "#{content_type};collection=true" } }
+            it 'validates successfully' do
               expect {
                 response_definition.validate_content_type!(response)
               }.to_not raise_error
@@ -405,7 +414,7 @@ describe Praxis::ResponseDefinition do
         it 'validates each part' do
           response_definition.parts
           expect {
-            response_definition.validate_parts!(response)  
+            response_definition.validate_parts!(response)
           }.to_not raise_error
         end
 
@@ -425,6 +434,7 @@ describe Praxis::ResponseDefinition do
 
   end
 
+
   context 'with invalid definitions' do
     it 'raises an error if status code is not part of the definition' do
       expect do
@@ -442,19 +452,19 @@ describe Praxis::ResponseDefinition do
     let(:parts) { nil }
 
     let(:response) do
-       Praxis::ResponseDefinition.new(:custom) do
-         status 300
-       end
+      Praxis::ResponseDefinition.new(:custom) do
+        status 300
+      end
     end
     subject(:output) { response.describe }
-    
+
     before do
       response.description(description) if description
       response.location(location) if location
-      response.parts(parts) if parts 
+      response.parts(parts) if parts
       response.headers(headers) if headers
     end
-    
+
     context 'for a definition without parts' do
       it{ should be_kind_of(::Hash) }
       its([:description]){ should be(description) }
@@ -465,33 +475,33 @@ describe Praxis::ResponseDefinition do
         expect( output[:headers]['Header1'] ).to eq({value: 'Value1' ,type: :string })
       end
     end
-    
+
     context 'for a definition with (homogeneous) parts' do
       subject(:described_parts){ output[:parts_like] }
       context 'using :like' do
         let(:parts) { {like: :ok, media_type: 'foobar'} }
-        
+
         it 'should contain a parts_like key with a hash' do
           expect( output ).to have_key(:parts_like)
         end
-        
-        it{ should be_kind_of(::Hash) }  
+
+        it{ should be_kind_of(::Hash) }
         its([:media_type]){ should == { identifier: 'foobar'} }
         its([:status]){ should == 200 }
       end
       context 'using a full response definition block' do
         let(:parts) do
-          Proc.new do 
+          Proc.new do
             status 234
             media_type 'custom_media'
           end
         end
-        
+
         it 'should contain a parts_like key with a hash' do
           expect( output ).to have_key(:parts_like)
         end
-        
-        it{ should be_kind_of(::Hash) }  
+
+        it{ should be_kind_of(::Hash) }
         its([:media_type]){ should == { identifier: 'custom_media'} }
         its([:status]){ should == 234 }
       end

data/spec/praxis/stage_spec.rb

@@ -13,8 +13,6 @@ describe Praxis::Stage do
 
   context ".run" do
     it "sets up and execute callbacks" do
-      expect(stage).to receive('setup!')
-      expect(stage).to receive('setup_deferred_callbacks!')
       expect(stage).to receive('execute')
       expect(stage).to receive('execute_callbacks').twice
       stage.run
@@ -22,7 +20,10 @@ describe Praxis::Stage do
   end
 
   context ".setup!" do
-    it "should do something"
+    it 'should call setup_deferred_callbacks' do
+      expect(stage).to receive('setup_deferred_callbacks!')
+      stage.setup!
+    end
   end
 
   context ".setup_deferred_callbacks!" do
@@ -40,11 +41,6 @@ describe Praxis::Stage do
   end
 
   context ".execute" do
-    it "raises error when @stages is empty" do
-      error_msg = 'Subclass must implement Stage#execute'
-      expect{stage.execute}.to raise_error(NotImplementedError, error_msg)
-    end
-
     it "runs all the stages" do
       double_stage = double("stage")
       expect(double_stage).to receive('run')

data/spec/praxis/types/collection_spec.rb

@@ -0,0 +1,144 @@
+require "spec_helper"
+
+describe Praxis::Collection do
+
+  let(:type) { Volume }
+  let(:example) { Volume.example('example-volume') }
+
+  let(:snapshots) { example.snapshots }
+
+  subject(:media_type_collection) do
+    Volume.attributes[:snapshots].type
+  end
+
+  context '.of' do
+    let(:media_type) do
+      Class.new(Praxis::MediaType) do
+        identifier 'an-awesome-type'
+      end
+    end
+
+    subject!(:collection) do
+      Praxis::Collection.of(media_type)
+    end
+
+    its(:identifier) { should eq 'an-awesome-type;type=collection' }
+
+    it 'sets the collection on the media type' do
+      expect(media_type::Collection).to be(collection)
+    end
+
+    it 'returns an existing Collection type' do
+      expect(Praxis::Collection.of(media_type)).to be(collection)
+    end
+
+    it 'works with explicitly-defined collections' do
+      expect(Praxis::Collection.of(Volume)).to be(Volume::Collection)
+    end
+  end
+
+  context 'defined explicitly' do
+    subject(:type) { Volume::Collection }
+    its(:member_type) { should be Volume }
+    its(:identifier) { should eq 'application/vnd.acme.volumes' }
+
+  end
+
+  context '.member_type' do
+    its(:member_type){ should be(VolumeSnapshot) }
+    its(:member_attribute){ should be_kind_of(Attributor::Attribute) }
+    its('member_attribute.type'){ should be(VolumeSnapshot) }
+  end
+  
+  context '.load' do
+    let(:volume_data) do
+      {
+        id: 1,
+        name: 'bob',
+        snapshots: snapshots_data
+      }
+    end
+
+    let(:snapshots_data) {
+      nil
+    }
+
+
+    context 'loading an array' do
+      let(:snapshots_data) do
+        [{id: 1, name: 'snapshot-1'},
+         {id: 2, name: 'snapshot-2'}]
+      end
+
+      let(:volume) { Volume.load(volume_data) }
+      subject(:snapshots) { volume.snapshots }
+
+      it 'sets the collection members' do
+        expect(snapshots).to have(2).items
+
+        expect(snapshots[0].id).to eq(1)
+        expect(snapshots[0].name).to eq('snapshot-1')
+        expect(snapshots[1].id).to eq(2)
+        expect(snapshots[1].name).to eq('snapshot-2')
+      end
+
+    end
+  end
+
+
+   context '#render' do
+
+
+    context 'for members' do
+      let(:volume_output) { example.render(:default) }
+
+      subject(:output) { volume_output[:snapshots] } 
+
+      it { should eq(snapshots.collect(&:render)) }
+    end
+
+
+   end
+
+  context '#validate' do
+    let(:volume_data) do
+      {
+        id: 1,
+        name: 'bob',
+        snapshots: snapshots_data
+      }
+    end
+
+    let(:snapshots_data) {
+      nil
+    }
+
+
+    context 'for an array' do
+      let(:snapshots_data) do
+        [{id: 1, name: 'snapshot-1'},
+         {id: 2, name: 'snapshot-2'}]
+      end
+
+      let(:volume) { Volume.load(volume_data) }
+      let(:snapshots) { volume.snapshots }
+      
+      it 'validates' do
+        expect(volume.validate).to be_empty
+      end
+
+      context 'with invalid members' do
+        let(:snapshots_data) do
+          [{id: 1, name: 'invalid-1'},
+           {id: 2, name: 'snapshot-2'}]
+        end
+
+        it 'returns the error' do
+          expect(volume.validate).to have(1).item
+          expect(volume.validate[0]).to match(/value \(invalid-1\) does not match regexp/)
+        end
+      end
+    end
+  end
+
+end

data/spec/spec_app/app/controllers/instances.rb

@@ -54,14 +54,14 @@ class Instances < BaseClass
   def bulk_create(cloud_id:)
     self.response = BulkResponse.new
 
+
     request.payload.each do |instance_id,instance|
       part_body = JSON.pretty_generate(key: instance_id, value: instance.render(:create))
       headers = {
         'Status' => '201',
         'Content-Type' => Instance.identifier,
-        'Location' => self.class.definition.actions[:show].primary_route.path.expand(cloud_id: cloud_id, id: instance.id)
+        'Location' => definition.to_href(cloud_id: cloud_id, id: instance.id)
       }
-
       part = Praxis::MultipartPart.new(part_body, headers)
 
       response.add_part(instance_id, part)
@@ -98,4 +98,10 @@ class Instances < BaseClass
     response
   end
 
+  def update(id:, cloud_id:)
+    response.body = JSON.pretty_generate(request.payload.dump)
+    response.headers['Content-Type'] = 'application/vnd.acme.instance'
+    response
+  end
+
 end