praxis 0.16.1 → 0.17.0

data/spec/praxis/action_definition_spec.rb

@@ -11,7 +11,7 @@ describe Praxis::ActionDefinition do
 
       media_type 'application/json'
       version '1.0'
-      prefix '/api/hello_world'
+      prefix '/foobars/hello_world'
       action_defaults do
         payload { attribute :inherited, String }
         headers { header "Inherited", String }
@@ -90,7 +90,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/hello_world/test_trait/:app_name/:one' }
+    its('routes.first.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
@@ -141,8 +141,32 @@ describe Praxis::ActionDefinition do
     end
   end
 
-  describe '#routing' do
-    it 'has some tests when Skeletor::RestfulRoutingConfig disappears'
+  context '#routing' do
+    context 'with a parent specified' do
+      let(:resource) { ApiResources::VolumeSnapshots }
+      subject(:action) { resource.actions[:show] }
+
+      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'
+      end
+
+      its('params.attributes'){ should have_key(:cloud_id) }
+
+      context 'with pre-existing parent param' do
+        let(:action) { resource.actions[:index] }
+        subject(:param) { action.params.attributes[:volume_id] }
+        its(:options) { should_not eq parent_param.options }
+      end
+
+      context 'with auto-generated param' do
+        subject(:param) { action.params.attributes[:volume_id] }
+        it { should_not be nil }
+        its(:options) { should eq parent_param.options }
+      end
+
+    end
   end
 
   context '#description' do
@@ -171,7 +195,7 @@ describe Praxis::ActionDefinition do
 
     it 'works' do
       expansion = action.primary_route.path.expand(cloud_id:232, id: 2)
-      expect(expansion).to eq "/clouds/232/instances/2"
+      expect(expansion).to eq "/api/clouds/232/instances/2"
     end
 
     context '#primary_route' do
@@ -228,7 +252,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/api/hello_world/:one' }
+    its('routes.first.path.to_s') { should eq '/apps/:app_name/foobars/hello_world/:one' }
     its('params.attributes.keys') { should eq [:inherited, :app_name, :one]}
 
     context 'where the action overrides a base_param' do
@@ -241,7 +265,7 @@ describe Praxis::ActionDefinition do
             'FooBar'
           end
           version '1.0'
-          prefix '/api/hello_world'
+          prefix '/foobars/hello_world'
           action_defaults do
             payload { attribute :inherited, String }
             headers { header "Inherited", String }

data/spec/praxis/api_definition_spec.rb

@@ -134,7 +134,7 @@ describe Praxis::ApiDefinition do
         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)
@@ -147,7 +147,7 @@ describe Praxis::ApiDefinition do
         expect(info[:name]).to eq("Spec App")
         expect(info[:title]).to eq("A simple App to do some simple integration testing")
         expect(info[:description]).to eq("A simple 1.0 App")
-        expect(info[:base_path]).to eq("/")
+        expect(info[:base_path]).to eq("/api")
       end
     end
 

data/spec/praxis/api_general_info_spec.rb

@@ -4,11 +4,17 @@ describe Praxis::ApiGeneralInfo do
 
   subject(:info){ Praxis::ApiGeneralInfo.new }
 
+  before do
+    allow(Praxis::Application.instance).to receive(:versioning_scheme=).with([:header, :params])
+  end
+
+
   let(:info_block) do
     Proc.new do
       name "Name"
       title "Title"
       description "Description"
+      endpoint 'api.example.com'
       base_path "/base"
       base_params do
         attribute :name, String
@@ -45,6 +51,25 @@ describe Praxis::ApiGeneralInfo do
     its([:base_path]) {should eq '/base' }
     its([:base_params]) { should have_key :name }
     its([:base_params, :name, :type, :name]) { should eq 'String' }
+    its([:version_with]) { should eq([:header, :params]) }
+    its([:endpoint]) { should eq 'api.example.com' }
+  end
+
+  context 'base_path with versioning' do
+    let(:global_info){ Praxis::ApiGeneralInfo.new }
+    subject(:info){ Praxis::ApiGeneralInfo.new(global_info, version: '1.0') }
 
+    before do
+      global_info
+
+      expect(Praxis::Application.instance).to receive(:versioning_scheme=).with(:path)
+
+      global_info.version_with :path
+      global_info.base_path '/api/v:api_version'
+    end
+    
+
+    its(:base_path) { should eq '/api/v1.0'}
   end
+
 end

data/spec/praxis/application_spec.rb

@@ -48,17 +48,9 @@ describe Praxis::Application do
     subject { Class.new(Praxis::Application).instance }
 
     before do
-      bootloader = double('bootloader')
-      allow(bootloader).to receive(:setup!).and_return(true)
-
-      app = double('built Rack app')
-
-      builder = double('Rack builder')
-      allow(builder).to receive(:run)
-      allow(builder).to receive(:to_app).and_return(app)
-
-      subject.instance_variable_set(:@bootloader, bootloader)
-      subject.instance_variable_set(:@builder, builder)
+      # don't actually bootload; we're merely running specs
+      allow(subject.bootloader).to receive(:setup!).and_return(true)
+      allow(subject.builder).to receive(:to_app).and_return(double('Rack app'))
     end
 
     describe '#handler' do
@@ -100,4 +92,25 @@ describe Praxis::Application do
       end
     end
   end
+
+  describe '#setup' do
+    subject { Class.new(Praxis::Application).instance }
+
+    before do
+      # don't actually bootload; we're merely running specs
+      allow(subject.bootloader).to receive(:setup!).and_return(true)
+      allow(subject.builder).to receive(:to_app).and_return(double('Rack app'))
+    end
+
+    it 'is idempotent' do
+      expect(subject.builder).to receive(:to_app).once
+      subject.setup
+      subject.setup
+    end
+
+    it 'returns itself' do
+      expect(subject.setup).to eq(subject)
+      expect(subject.setup).to eq(subject)
+    end
+  end
 end

data/spec/praxis/handlers/xml_spec.rb

@@ -3,8 +3,10 @@ require 'spec_helper'
 describe Praxis::Handlers::XML do
 
   describe '#parse' do
-    after do
-      expect( subject.parse(xml) ).to eq(parsed)
+    shared_examples 'xml something' do
+      it 'works' do
+        expect(subject.parse(parsed.to_xml)).to eq(parsed)
+      end
     end
 
     #  XML_TYPE_NAMES = {
@@ -23,72 +25,81 @@ describe Praxis::Handlers::XML do
     context "Parsing symbols" do
       let(:xml){ '<objects type="array"><object type="symbol">a_symbol</object></objects>' }
       let(:parsed){ [:a_symbol] }
-      it 'works' do end
+      it_behaves_like 'xml something'
     end
 
     context "Parsing integers" do
       let(:xml){ '<objects type="array"><object type="integer">1234</object></objects>' }
       let(:parsed){ [1234] }
-      it 'works' do end
+      it_behaves_like 'xml something'
     end
 
     context "Parsing decimals" do
       let(:xml){ '<objects type="array"><object type="decimal">0.1</object></objects>' }
       let(:parsed){ [0.1] }
-      it 'works' do end
+      it_behaves_like 'xml something'
     end
 
     context "Parsing floats" do
       let(:xml){ '<objects type="array"><object type="float">0.1</object></objects>' }
       let(:parsed){ [0.1] }
-      it 'works' do end
+      it_behaves_like 'xml something'
     end
 
     context "Parsing booleans" do
       context "that are true" do
         let(:xml){ '<objects type="array"><object type="boolean">true</object></objects>' }
         let(:parsed){ [true] }
-        it 'works' do end
+        it_behaves_like 'xml something'
       end
       context "that are false" do
         let(:xml){ '<objects type="array"><object type="boolean">false</object></objects>' }
         let(:parsed){ [false] }
-        it 'works' do end
+        it_behaves_like 'xml something'
+
       end
     end
 
     context "Parsing dates" do
       let(:xml){ '<objects type="array"><object type="date">2001-01-01</object></objects>' }
       let(:parsed){ [Date.parse("2001-01-01")] }
-      it 'works' do end
+      it_behaves_like 'xml something'
     end
 
     context "Parsing dateTimes" do
       let(:xml){ '<objects type="array"><object type="dateTime">2015-03-13T19:34:40-07:00</object></objects>' }
       let(:parsed){ [DateTime.parse("2015-03-13T19:34:40-07:00")] }
-      it 'works' do end
+      it_behaves_like 'xml something'
     end
 
     context "Parsing hashes" do
       context "that are empty" do
-        let(:xml){ '<hash></hash>' }
-        let(:parsed){ {} }
-        it 'works' do end
+        let(:xml){ "<hash></hash>" }
+
+        it 'get converted to empty strings' do
+          expect(subject.parse(xml)).to eq('')
+        end
       end
+
       context "with a couple of elements" do
         let(:xml){ '<hash><one type="integer">1</one><two type="integer">2</two></hash>' }
         let(:parsed){ {"one"=>1, "two"=>2} }
-        it 'works' do end
+        it_behaves_like 'xml something'
+      end
+      context "with hyphenated elements" do
+        let(:xml){ '<hash><part-one type="integer">1</part-one><part-two type="integer">2</part-two></hash>' }
+        let(:parsed){ {"part_one"=>1, "part_two"=>2} }
+        it_behaves_like 'xml something'
       end
       context "with a nested hash" do
         let(:xml){ '<hash><one type="integer">1</one><sub_hash><first>hello</first></sub_hash></hash>' }
         let(:parsed){ {"one"=>1, "sub_hash"=>{"first"=>"hello"} } }
-        it 'works' do end
+        it_behaves_like 'xml something'
       end
       context "with a nested array" do
         let(:xml){ '<hash><one type="integer">1</one><two type="array"><object>just text</object></two></hash>' }
         let(:parsed){ {"one"=>1, "two" => ["just text"] } }
-        it 'works' do end
+        it_behaves_like 'xml something'
       end
 
     end
@@ -97,12 +108,12 @@ describe Praxis::Handlers::XML do
       context 'with a couple of simple elements in it' do
         let(:xml){ '<objects type="array"><object>just text</object><object type="integer">1</object></objects>' }
         let(:parsed){ ["just text", 1] }
-        it 'works' do end
+        it_behaves_like 'xml something'
       end
       context "with a nested hash" do
         let(:xml){ '<objects type="array"><object>just text</object><object><one type="integer">1</one></object></objects>' }
         let(:parsed){ ["just text", { "one" => 1}] }
-        it 'works' do end
+        it_behaves_like 'xml something'
       end
     end
 
@@ -110,40 +121,51 @@ describe Praxis::Handlers::XML do
       let(:xml){ parsed.to_xml }
       context 'array with a couple of simple elements in it' do
         let(:parsed){ ["just text", 1] }
-        it 'works' do end
+        it_behaves_like 'xml something'
       end
       context 'a hash with a couple of simple elements in it' do
         let(:parsed){ { "one"=>"just text", "two"=> 1 } }
-        it 'works' do end
+        it_behaves_like 'xml something'
       end
       context 'a array with elements of all types' do
         let(:parsed){ ["just text",:a,1,BigDecimal.new(100),0.1,true,Date.new] }
-        it 'works' do end
+        it_behaves_like 'xml something'
       end
       context 'a hash with a complex substructure' do
         let(:parsed) do
           Hash(
-              "text" => "just text",
-              "symbol" => :a,
-              "num" => 1,
-              "BD" => BigDecimal.new(100),
-              "float" => 0.1,
-              "truthyness" => true,
-              "day" => Date.new )
+            "text" => "just text",
+            "symbol" => :a,
+            "num" => 1,
+            "bd" => BigDecimal.new(100),
+            "float" => 0.1,
+            "truthyness" => true,
+            "day" => Date.new,
+            "empty_string" => ""
+          )
         end
-        it 'works' do end
+        it_behaves_like 'xml something'
       end
 
       context "transformed characters when using .to_xml" do
         context 'underscores become dashes' do
           let(:xml){ {"one_thing"=>1, "two_things"=>2}.to_xml  }
-          let(:parsed){ {"one-thing"=>1, "two-things"=>2} }
-          it 'works' do end
+          it do
+            doc = Nokogiri::XML(xml)
+
+            expect(doc.search('one-thing')).to_not be_empty
+            expect(doc.search('two-things')).to_not be_empty
+          end
         end
         context 'spaces become dashes' do
           let(:xml){ {"one thing"=>1, "two things"=>2}.to_xml  }
           let(:parsed){ {"one-thing"=>1, "two-things"=>2} }
-          it 'works' do end
+          it do
+            doc = Nokogiri::XML(xml)
+
+            expect(doc.search('one-thing')).to_not be_empty
+            expect(doc.search('two-things')).to_not be_empty
+          end
         end
       end
     end
@@ -152,4 +174,4 @@ describe Praxis::Handlers::XML do
       it 'has tests'
     end
   end
-end
+end

data/spec/praxis/links_spec.rb

@@ -19,7 +19,7 @@ describe Praxis::Links do
     expect(link.for(Address)).to eq(link)
   end
 
-  context 'rendering' do
+  context 'contents' do
     subject(:view) { link.view(:default) }
 
     its(:name)      { should eq(:default) }
@@ -28,6 +28,23 @@ describe Praxis::Links do
     its(:contents)  { should have_key(:super) }
   end
 
+  context 'rendering' do
+    let(:example){ Address.example }
+    context 'for :default' do
+      subject(:rendered_links){ example.render(view: :default)[:links] }
+
+      it 'should use the :link for rendering its attributes' do
+        expect(rendered_links[:owner]).to eq( example.owner.render(view: :link))
+      end
+    end
+    context 'for :master' do
+      subject(:rendered_links){ example.render(view: :master)[:links] }
+      it 'should use the :link for rendering its attributes' do
+        expect(rendered_links[:owner]).to eq( example.owner.render(view: :link))
+      end
+    end
+  end
+
   context '.example' do
     subject(:example) { Address.example }
 

data/spec/praxis/media_type_collection_spec.rb

@@ -78,7 +78,7 @@ describe Praxis::MediaTypeCollection do
     context 'for standard views' do
       let(:snapshots_data) { {name: 'snapshots',   href: '/bob/snapshots' } }
       let(:snapshots) { media_type_collection.load(snapshots_data) }
-      subject(:output) { snapshots.render(:link) }
+      subject(:output) { snapshots.render(view: :link) }
 
       its([:name]) { should eq(snapshots.name)}
       its([:size]) { should eq(snapshots.size)}

data/spec/praxis/media_type_spec.rb

@@ -96,7 +96,7 @@ describe Praxis::MediaType do
   end
 
   context "rendering" do
-    subject(:output) { address.render(:default) }
+    subject(:output) { address.render(view: :default) }
 
     its([:id])    { should eq(address.id) }
     its([:name])  { should eq(address.name) }
@@ -112,7 +112,7 @@ describe Praxis::MediaType do
       context 'for a collection summary' do
         let(:volume) { Volume.example }
         let(:snapshots_summary) { volume.snapshots_summary }
-        let(:output) { volume.render(:default) }
+        let(:output) { volume.render(view: :default) }
         subject { links[:snapshots] }
 
         its([:name]) { should eq(snapshots_summary.name) }

data/spec/praxis/multipart/parser_spec.rb

@@ -19,11 +19,14 @@ describe Praxis::MultipartParser do
   subject(:parts) { parser.parse[1] }
 
   context 'with simple parts' do
+    it { should be_kind_of(Array) }
     it { should have(1).item }
-    it { should have_key('destination_path') }
 
-    it 'sets the right values on the part' do
-      expect(parts['destination_path'].body).to eq('/etc/defaults')
+    context 'the parsed parts' do
+      subject(:part) { parts.first }
+
+      its(:name) { should eq 'destination_path' }
+      its(:body) { should eq '/etc/defaults' }
     end
   end
 
@@ -33,20 +36,25 @@ describe Praxis::MultipartParser do
       form.add text, 'file', 'docker'
     end
 
-    subject(:file_part_body) { parts['file'].body }
+    subject(:part) { parts.find { |p| p.name == 'file'} }
+    #subject(:part_body) { part.body }
+
 
-    it { should be_kind_of(Hash) }
-    its([:filename]) { should eq("docker") }
-    its([:name]) { should eq("file") }
-    its([:type]) { should eq("text/plain") }
-    its([:tempfile]) { should be_kind_of(Tempfile)}
-    its([:head]) { should match(/Content-Disposition/) } 
+    its(:payload) { should be_kind_of(Tempfile) }
+    its(:filename) { should eq("docker") }
+    its(:name) { should eq("file") }
+
+    context 'headers' do
+      subject(:part_headers) { part.headers }
+      its(['Content-Type']) { should eq("text/plain") }
+      its(['Content-Disposition']) { should match(/filename=docker/) }
+    end
 
     it 'saves the value to the tempfile' do
-      expect(File.exist?(file_part_body[:tempfile].path)).to be(true)
+      expect(File.exist?(part.payload.path)).to be(true)
 
-      file_part_body[:tempfile].rewind
-      expect(file_part_body[:tempfile].read).to eq('DOCKER_HOST=tcp://127.0.0.1:2375')
+      part.payload.rewind
+      expect(part.payload.read).to eq('DOCKER_HOST=tcp://127.0.0.1:2375')
     end
 
   end