praxis 0.13.0 → 0.14.0

data/spec/api_browser/filters/attribute_name_spec.js

@@ -0,0 +1,23 @@
+describe('attributeName filter', function() {
+  var filter;
+  beforeEach(angular.mock.module('PraxisDocBrowser'));
+
+  beforeEach(inject(function(attributeNameFilter, $sce) {
+    filter = function(input) {
+      return $sce.getTrusted('html', attributeNameFilter(input));
+    };
+  }));
+
+  it('only modifies input with one dot', function() {
+    expect(function(str) {
+      var dotsCount = str.split('.').length - 1;
+      if (dotsCount !== 1) {
+        return str === filter(str);
+      }
+    }).forAll(qc.string);
+  });
+
+  it('adds a tag to the prefix', function() {
+    expect(filter('ns.test')).toEqual('<span class="attribute-prefix">ns.</span>test');
+  });
+});

data/spec/functional_spec.rb

@@ -10,6 +10,14 @@ describe 'Functional specs' do
 
   context 'index' do
 
+    context 'with a valid request' do
+      it 'is successful' do
+        get '/clouds/1/instances?api_version=1.0', nil, 'global_session' => session
+        expect(last_response.headers['Content-Type']).to(
+        eq("application/vnd.acme.instance;type=collection"))
+      end
+    end
+
     context 'with an incorrect response_content_type param' do
       around do |example|
         logger = app.logger
@@ -52,15 +60,25 @@ describe 'Functional specs' do
   it 'works' do
     get '/clouds/1/instances/2?junk=foo&api_version=1.0', nil, 'global_session' => session
     expect(last_response.status).to eq(200)
-    expect(JSON.parse(last_response.body)).to eq({"cloud_id" => 1, "id"=>2, "junk"=>"foo",
-                                                  "other_params"=>{
-                                                    "some_date"=>"2012-12-21T00:00:00+00:00",
-                                                  "fail_filter"=>false},
-                                                  "payload"=>{"something"=>nil, "optional"=>"not given"}})
-    expect(last_response.headers).
-      to eq({"Content-Type"=>"application/vnd.acme.instance",
-             "Content-Length"=>"214", 'Spec-Middleware' => 'used'})
-      end
+    expected = {
+      "cloud_id" => 1,
+      "id"=>2,
+      "junk"=>"foo",
+      "other_params"=>{
+        "some_date"=>"2012-12-21T00:00:00+00:00",
+        "fail_filter"=>false
+      },
+      "payload"=>{
+      "optional"=>"not given"}
+    }
+
+    expect(JSON.parse(last_response.body)).to eq(expected)
+
+    headers = last_response.headers
+    expect(headers['Content-Type']).to eq('application/vnd.acme.instance')
+    expect(headers['Spec-Middleware']).to eq('used')
+    expect(headers['Content-Length']).to eq(last_response.body.size.to_s)
+  end
 
   it 'returns early when making the before filter break' do
     get '/clouds/1/instances/2?junk=foo&api_version=1.0&fail_filter=true', nil, 'global_session' => session
@@ -267,7 +285,7 @@ describe 'Functional specs' do
     end
 
   end
-  
+
   context 'auth_plugin' do
     it 'can terminate' do
       post '/clouds/23/instances/1/terminate?api_version=1.0', nil, 'global_session' => session
@@ -295,4 +313,38 @@ describe 'Functional specs' do
     end
   end
 
+  context 'update' do
+    
+
+    let(:body) { JSON.pretty_generate(request_payload) }
+    let(:content_type) { 'application/json' }
+
+    before do
+      patch '/clouds/1/instances/3?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
+    end
+  
+    subject(:response_body) { JSON.parse(last_response.body) }
+
+    context 'with an empty payload' do
+      let(:request_payload) { {} }
+      it { should be_empty }
+      it { should_not have_key('name') }
+      it { should_not have_key('root_volume') }
+    end
+
+    context 'with a provided name' do
+      let(:request_payload) { {name: 'My Instance'} }
+      its(['name']) { should eq('My Instance') }
+      it { should_not have_key('root_volume') }
+    end
+
+    context 'with an explicitly-nil root_volme' do
+      let(:request_payload) { {name: 'My Instance', root_volume: nil} }
+      its(['name']) { should eq('My Instance') }
+      its(['root_volume']) { should be(nil) }
+    end
+
+
+  end
+
 end

data/spec/praxis/action_definition_spec.rb

@@ -21,7 +21,7 @@ describe Praxis::ActionDefinition do
   end
 
   subject(:action) do
-    Praxis::ActionDefinition.new('foo', resource_definition) do
+    Praxis::ActionDefinition.new(:foo, resource_definition) do
       routing { get '/:one' }
       payload { attribute :two, String }
       headers { header "X_REQUESTED_WITH", 'XMLHttpRequest' }
@@ -30,7 +30,7 @@ describe Praxis::ActionDefinition do
   end
 
   context '#initialize' do
-    its('name')                { should eq 'foo' }
+    its('name')                { should eq :foo }
     its('resource_definition') { should be resource_definition }
     its('params.attributes')   { should have_key :one }
     its('params.attributes')   { should have_key :inherited }
@@ -116,7 +116,16 @@ describe Praxis::ActionDefinition do
   end
 
   context '#describe' do
-    it 'has some tests when Skeletor::RestfulRoutingConfig disappears'
+    subject(:describe) { action.describe }
+
+    context 'params' do
+      subject(:param_description) { describe[:params] }
+      it 'includes attribute sources' do
+        attributes = param_description[:type][:attributes]
+        expect(attributes[:inherited][:source]).to eq('query')
+        expect(attributes[:one][:source]).to eq('url')
+      end
+    end
   end
 
   context 'href generation' do
@@ -156,5 +165,4 @@ describe Praxis::ActionDefinition do
     end
 
   end
-
 end

data/spec/praxis/api_definition_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+describe Praxis::ApiDefinition do
+  
+  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 {} 
+    end
+    api_def
+  end
+  
+  let(:info_block) do
+    Proc.new do
+      name "Name"
+      title "Title"
+    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
+  
+  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)
+    end
+    it 'also works outside a .define block' do
+      api.response_template :foobar, &response_template
+      expect(api.responses.keys).to include(:foobar)
+      expect(api.response(:foobar)).to be_kind_of(Praxis::ResponseTemplate)
+    end
+  end
+  
+  context '.response' do
+    let(:api){ non_singleton_api }
+
+    it 'returns a registered response by name' 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)
+    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{ 
+        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 }
+
+    context 'with a version' do
+      it 'saves the data into the correct version hash' do
+        expect(api.infos.keys).to_not include("9.0")
+        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    
+    context 'without a version' do
+      it 'saves it into nil if no version is passed' do
+        expect(api.infos.keys).to_not include(nil)
+        api.info do
+          description "Global Description"
+        end
+        expect(api.infos.keys).to include(nil)
+      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
+
+      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)
+        expect(info[:schema_version]).to eq("1.0")
+        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("/")
+      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") }  
+      
+      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"})
+          expect(v9_info).to include({title: "Title"})
+        end
+        it 'inherited the description from the nil(global) one' do
+          expect(v9_info).to include({description: "Global Description"})
+        end
+      
+      end
+    end
+  end
+end

data/spec/praxis/api_general_info_spec.rb

@@ -0,0 +1,36 @@
+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"
+    end
+  end
+  
+  context 'DSLs' do
+    it 'accepts the appropriate DSLs' do
+      expect{ 
+        info.instance_exec &info_block
+      }.to_not raise_error
+    end
+    
+  end
+
+  context '.describe' do
+    subject(:output){ info.describe }
+    it 'works' do
+      info.instance_exec &info_block
+      expect(output).to eq( 
+        {:schema_version=>"1.0", :name=>"Name", :title=>"Title", 
+          :description=>"Description", :base_path=>"/base"
+        })
+    end
+    
+  end
+end

data/spec/praxis/bootloader_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Praxis::Bootloader do
   let(:application) do
-    instance_double("Praxis::Application", config: "config", root: "root", plugins: {})
+    instance_double("Praxis::Application", config: "config", root: "root", plugins: {}, file_layout: {} )
   end
 
   subject(:bootloader) {Praxis::Bootloader.new(application)}
@@ -17,6 +17,15 @@ describe Praxis::Bootloader do
     its(:root) {should be(application.root)}
   end
 
+  context ".run" do
+    it "should call setup and run for all the stages" do
+      bootloader.stages.each do |s|
+        expect(s).to receive(:setup!).once
+        expect(s).to receive(:run).once
+      end
+      bootloader.run
+    end
+  end
   context ".delete_stage" do
     it "delete valid stage" do
       bootloader.delete_stage(:app)

data/spec/praxis/media_type_collection_spec.rb

@@ -2,49 +2,49 @@ require "spec_helper"
 
 describe Praxis::MediaTypeCollection do
 
-  let(:type) { Volume }
-  let(:example) { Volume.example('example-volume') }
+  subject!(:media_type_collection) do
+    silence_warnings do
+      klass = Class.new(Praxis::MediaTypeCollection) do
+        member_type VolumeSnapshot
+
+        attributes do
+          attribute :name, String, regexp: /snapshots-(\w+)/
+          attribute :size, Integer
+          attribute :href, String
+        end
+
+        view :link do
+          attribute :name
+          attribute :size
+          attribute :href
+        end
 
-  let(:snapshots) { example.snapshots }
+        member_view :default, using: :default
+      end
 
-  subject(:media_type_collection) do
-    Class.new(Praxis::MediaTypeCollection) do
-      member_type Volume
+      klass.finalize!
+      klass
     end
   end
    
   context '.member_type' do
-    its(:member_type){ should be(Volume) }
+    its(:member_type){ should be(VolumeSnapshot) }
     its(:member_attribute){ should be_kind_of(Attributor::Attribute) }
-    its('member_attribute.type'){ should be(Volume) }
+    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 'with a hash' do
       let(:snapshots_data) { {name: 'snapshots',   href: '/bob/snapshots' } }
+      subject(:snapshots) { media_type_collection.load(snapshots_data) }
 
-      let(:volume) { Volume.load(volume_data) }
-      subject(:snapshots) { volume.snapshots }
+       its(:name) { should eq(snapshots_data[:name]) }
+       its(:href) { should eq(snapshots_data[:href]) }
 
-      its(:name) { should eq(snapshots_data[:name]) }
-      its(:href) { should eq(snapshots_data[:href]) }
-
-      it 'has no members set' do
-        expect(snapshots.to_a).to eq([])
-      end
-    end
+       it 'has no members set' do
+         expect(snapshots.to_a).to eq([])
+       end
+     end
 
 
     context 'loading an array' do
@@ -52,9 +52,8 @@ describe Praxis::MediaTypeCollection do
         [{id: 1, name: 'snapshot-1'},
          {id: 2, name: 'snapshot-2'}]
       end
-
-      let(:volume) { Volume.load(volume_data) }
-      let(:snapshots) { volume.snapshots }
+      
+      let(:snapshots) { media_type_collection.load(snapshots_data) }
       subject(:members) { snapshots.to_a }
 
       it 'sets the collection members' do
@@ -75,10 +74,10 @@ describe Praxis::MediaTypeCollection do
     end
   end
 
-
   context '#render' 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) }
 
       its([:name]) { should eq(snapshots.name)}
@@ -86,8 +85,15 @@ describe Praxis::MediaTypeCollection do
       its([:href]) { should eq(snapshots.href)}
     end
 
-    context 'for member views' do
-      subject(:output) { snapshots.render(:default) }
+    context 'for members' do
+      let(:snapshots_data) do
+        [{id: 1, name: 'snapshot-1'},
+         {id: 2, name: 'snapshot-2'}]
+      end
+
+      let(:snapshots) { media_type_collection.load(snapshots_data) }
+
+      subject(:output) { media_type_collection.dump(snapshots, view: :default) }
 
       it { should eq(snapshots.collect(&:render)) }
     end
@@ -96,23 +102,12 @@ describe Praxis::MediaTypeCollection do
   end
 
   context '#validate' do
-    let(:volume_data) do
-      {
-        id: 1,
-        name: 'bob',
-        snapshots: snapshots_data
-      }
-    end
-
-    let(:snapshots_data) {
-      nil
-    }
+ 
 
     context 'with a hash' do
       let(:snapshots_data) { {name: 'snapshots-1',   href: '/bob/snapshots' } }
+      subject(:snapshots) { media_type_collection.load(snapshots_data) }
 
-      let(:volume) { Volume.load(volume_data) }
-      subject(:snapshots) { volume.snapshots }
 
       it 'validates' do
         expect(snapshots.validate).to be_empty
@@ -133,10 +128,8 @@ describe Praxis::MediaTypeCollection do
          {id: 2, name: 'snapshot-2'}]
       end
 
-      let(:volume) { Volume.load(volume_data) }
-      let(:snapshots) { volume.snapshots }
-      subject(:members) { snapshots.to_a }
-      
+      subject(:snapshots) { media_type_collection.load(snapshots_data) }
+
       it 'validates' do
         expect(snapshots.validate).to be_empty
       end