praxis 0.0.1 → 0.9

data/spec/praxis/config_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe Praxis::Config do
+  subject(:config) do
+    Praxis::Config.new
+  end
+
+  describe '#initialize' do
+    it 'its type is a Struct type' do
+      expect( config.attribute.type < Attributor::Struct).to be(true)
+    end
+    it 'has no value' do
+      expect(config.get.attributes).to eq({})
+    end
+  end
+
+  describe '#define' do
+    context 'using a block' do
+      context 'at the top level' do
+        let(:key) { nil}  
+        before do
+          config.define key do
+            attribute :foo, String
+          end
+        end
+        
+        it 'defines a Struct-type configuration under :foo' do
+          expect(config.attribute.attributes.keys).to eq [:foo]
+        end
+        
+        context 'called again with new attributes' do
+          before do
+            config.define key do
+              attribute :bar, String
+            end
+          end
+        
+          it 'adds the additional attributes to the Struct under :bar' do
+            expect(config.attribute.attributes.keys).to eq [:foo, :bar]
+          end
+        end
+      end
+      context 'for a sub-key' do
+        let(:key) { :subkey }
+        before do
+          config.define key do
+            attribute :inside, String
+          end
+        end
+        it 'when it does not exist, it creates a whole new subkey Struct containing one key' do
+           expect(config.attribute.attributes[:subkey].attributes.keys).to eq [:inside]
+        end
+        it 'when it already exists, will fail if it is of a different type' do
+          expect{
+            config.define key, Attributor::Hash
+          }.to raise_error(/Incompatible type received for extending configuration key/)
+        end
+        it 'when it already exists, it add another subkey to the existing Struct' do
+          config.define key do
+             attribute :inside2, String 
+           end
+          expect(config.attribute.attributes[:subkey].attributes.keys).to eq [:inside,:inside2]
+        end
+
+      end
+    end
+    
+    context 'using a direct type' do
+      let(:config_type){ Attributor::Hash.of(key:String) }
+      let(:config_opts){ {} }
+      let(:config_key){ :foo }
+      
+      it 'it is not allowed if its for the top key' do
+        expect{
+          config.define nil, config_type, config_opts
+        }.to raise_error(/You cannot define the top level configuration with a non-Struct type/)
+      end
+      
+      before do
+        config.define config_key, config_type, config_opts
+      end
+
+      it 'sets the attribute to the defined type' do
+        expect(config.attribute.attributes[config_key].type).to be(config_type)
+      end
+      it 'does not allow to redefine types that are not Structs' do
+        expect{ 
+          config.define config_key, Attributor::Hash
+        }.to raise_error(Praxis::Exceptions::InvalidConfiguration,
+                         /Incompatible type received for extending configuration key/)
+      end
+    end
+  end
+
+  describe '#set' do
+    it 'sets configuration values' do
+      config.define do
+        attribute :foo, String
+      end
+      config.set({ foo: 'bar' })
+      expect(config.get.foo).to eq 'bar'
+    end
+
+    it 'fails when config does not validate' do
+      config.define do
+        attribute :foo, String, required: true
+      end
+      expect{ config.set({}) }.to raise_error(Praxis::Exceptions::ConfigValidation)
+    end
+
+    it 'fails when config cannot be loaded' do
+      config.define do
+        attribute :foo, Integer, required: true
+      end
+      expect{ config.set({foo: 'five'}) }.to raise_error(Praxis::Exceptions::ConfigLoad)
+    end
+  end
+end

data/spec/praxis/content_type_parser_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Praxis::ContentTypeParser do
+
+  describe '.parse' do
+    context 'when content type is blank'  do
+      it 'complains' do
+        expect{ subject.parse(nil) }.to  raise_error(ArgumentError)
+        expect{ subject.parse('') }.to   raise_error(ArgumentError)
+        expect{ subject.parse('  ') }.to raise_error(ArgumentError)
+     end
+    end
+
+    context 'when content type is weird'  do
+      it 'complains' do
+        expect{ subject.parse('+json') }.to raise_error(ArgumentError)
+        expect{ subject.parse(';p1=2') }.to raise_error(ArgumentError)
+     end
+    end
+
+    context 'when content type has only type'  do
+      it 'returns the type only' do
+        content_type = 'application/json'
+        expectation  = {
+          type: 'application/json'
+        }
+        expect(subject.parse(content_type)).to eq(expectation)
+      end
+    end
+
+    context 'when content type has type and subtype'  do
+      it 'returns both the type and the sub_type' do
+        content_type = 'application/vnd.something+json'
+        expectation  = {
+          type:     'application/vnd.something',
+          sub_type: 'json'
+        }
+        expect(subject.parse(content_type)).to eq(expectation)
+      end
+    end
+
+    context 'when content type has type and params'  do
+      it 'returns both the type and the params' do
+        content_type = 'application/json;p1=2;no_value;foo=bar'
+        expectation  = {
+          type:   'application/json',
+          params: {"p1"=>"2", "no_value"=>nil, "foo"=>"bar"}
+        }
+        expect(subject.parse(content_type)).to eq(expectation)
+      end
+    end
+
+    context 'when content type has type, sub_type and params'  do
+      it 'returns them all' do
+        content_type = 'application/vnd.something+json;p1=2;no_value;foo=bar'
+        expectation  = {
+          type:     'application/vnd.something',
+          sub_type: 'json',
+          params:   {"p1"=>"2", "no_value"=>nil, "foo"=>"bar"}
+        }
+        expect(subject.parse(content_type)).to eq(expectation)
+      end
+    end
+
+
+    context 'when there are spaces all around it should ignore them'  do
+      it 'returns them all' do
+        content_type = '  application/vnd.something+json ;   p1=2 ;no_value  ;  foo=bar ; '
+        expectation  = {
+          type:     'application/vnd.something',
+          sub_type: 'json',
+          params:   {"p1"=>"2", "no_value"=>nil, "foo"=>"bar"}
+        }
+        expect(subject.parse(content_type)).to eq(expectation)
+      end
+    end
+
+
+    context 'when there are multiple ;;;;;;'  do
+      it 'ignores them' do
+        content_type = 'application/vnd.something+json;;;; ; ;;;;  ;;'
+        expectation  = {
+          type:     'application/vnd.something',
+          sub_type: 'json'
+        }
+        expect(subject.parse(content_type)).to eq(expectation)
+      end
+    end
+
+  end
+end

data/spec/praxis/controller_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Praxis::Controller do
+  subject do
+    Class.new {
+      include Praxis::Controller
+
+      implements PeopleResource
+
+      before :validate, actions: [:index] do
+        "before"
+      end
+
+      before actions: [:show] do
+      end
+
+      after :response, actions: [:show] do
+        "after"
+      end
+
+      def index
+      end
+
+      def show
+      end
+    }
+  end
+
+  context '.implements' do
+    it 'set the resource definition controller' do
+      expect(subject).to eq(PeopleResource.controller)
+    end
+  end
+
+  context '.actions' do
+    it 'gets the controller actions' do
+      expect(subject.actions.keys).to match_array([:index, :show])
+      expect(subject.actions[:index]).to be_kind_of(Praxis::ActionDefinition)
+      expect(subject.actions[:index].name).to eq(:index)
+    end
+  end
+
+  context '.action' do
+    it 'gets the index action of the controller' do
+      expect(subject.action(:index)).to be_kind_of(Praxis::ActionDefinition)
+      expect(subject.action(:index).name).to eq(:index)
+    end
+  end
+
+  context '.before' do
+    let(:validate_conditions) { subject.before_callbacks[[:validate]][0][0] }
+    let(:validate_block) { subject.before_callbacks[[:validate]][0][1] }
+
+    it 'sets up the before_callbacks' do
+      expect(subject.before_callbacks.keys).to match_array([[:validate], [:action]])
+      expect(validate_conditions).to eq({:actions => [:index]})
+      expect(validate_block).to be_kind_of(Proc)
+      expect(validate_block.call(*validate_conditions)).to eq("before")
+    end
+  end
+
+  context '.after' do
+    let(:response_conditions) { subject.after_callbacks[[:response]][0][0] }
+    let(:response_block) { subject.after_callbacks[[:response]][0][1] }
+
+    it 'sets up the after_callbacks' do
+      expect(subject.after_callbacks.keys).to match_array([[:response]])
+      expect(response_conditions).to eq({:actions => [:show]})
+      expect(response_block).to be_kind_of(Proc)
+      expect(response_block.call(*response_conditions)).to eq("after")
+    end
+  end
+end

data/spec/praxis/file_group_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Praxis::FileGroup do
+  let(:app) { Praxis::Application.instance }
+  let(:layout) { app.file_layout }
+
+  context '#base' do
+    it 'returns the base path for the group' do
+      expect(layout[:design].base.to_s).to eq(File.join(app.root, 'design/'))
+    end
+  end
+
+  context '#groups' do
+    subject(:groups) { layout.groups }
+
+    it 'returns a hash' do
+      expect(groups).to be_kind_of(Hash)
+    end
+
+    it 'shows the files mapped to groups' do
+      expect(groups).to have_key(:app)
+      expect(groups).to have_key(:design)
+      expect(groups[:app]).to be_kind_of(described_class)
+    end
+  end
+
+  context '#[]' do
+    it 'returns files in a specific group' do
+      expect(layout[:app]).to eq(layout.groups[:app])
+      expect(layout[:design]).to be_kind_of(described_class)
+      expect(layout[:design][:media_types]).to eq(layout.groups[:design].groups[:media_types])
+    end
+  end
+end

data/spec/praxis/links_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Praxis::Links do
+  let(:owner_resource) do
+    double('owner', id: 100, name: /[:name:]/.gen, href: '/')
+  end
+
+  let(:manager_resource) do
+    double('manager', id: 101, name: /[:name:]/.gen, href: '/')
+  end
+
+  let(:resource) do
+    double('address', id: 1, name: 'Home', owner: owner_resource, manager: manager_resource)
+  end
+
+  subject(:link) { described_class.for(Address) }
+
+  it 'returns the link class for the media type if defined' do
+    expect(link.for(Address)).to eq(link)
+  end
+
+  context 'rendering' do
+    subject(:view) { link.view(:default) }
+
+    its(:name)      { should eq(:default) }
+    its(:schema)    { should eq(Address::Links) }
+    its(:contents)  { should have_key(:owner) }
+    its(:contents)  { should have_key(:super) }
+  end
+
+  context '.example' do
+    subject(:example) { Address.example }
+
+    its('links.owner') { should be(example.owner) }
+    its('links.super') { should be(example.object.manager) }
+
+    it 'does not respond to non-top-level attributes from links' do
+      expect { example.super }.to raise_error(NoMethodError)
+    end
+
+    it 'responds to non-top-level attributes from links on its inner Struct' do
+      expect(example.links.super).to be(example.object.manager)
+    end
+  end
+end

data/spec/praxis/media_type_collection_spec.rb

@@ -0,0 +1,145 @@
+require "spec_helper"
+
+describe Praxis::MediaTypeCollection do
+
+  let(:type) { Volume }
+  let(:example) { Volume.example('example-volume') }
+
+  let(:snapshots) { example.snapshots }
+
+  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' } }
+
+      let(:volume) { Volume.load(volume_data) }
+      subject(:snapshots) { volume.snapshots }
+
+      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
+
+
+    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) }
+      let(:snapshots) { volume.snapshots }
+      subject(:members) { snapshots.to_a }
+
+      it 'sets the collection members' do
+        expect(members).to have(2).items
+
+        expect(members[0].id).to eq(1)
+        expect(members[0].name).to eq('snapshot-1')
+        expect(members[1].id).to eq(2)
+        expect(members[1].name).to eq('snapshot-2')
+      end
+
+      it 'has no attributes set' do
+        expect(snapshots.name).to be(nil)
+        expect(snapshots.size).to be(nil)
+        expect(snapshots.href).to be(nil)
+      end
+
+    end
+  end
+
+
+  context '#render' do
+
+    context 'for views that are not defined on on the collection' do
+      subject(:output) { snapshots.render(:default) }
+
+      it { should eq(snapshots.collect(&:render)) }
+    end
+
+    context 'for defined views' do
+      subject(:output) { snapshots.render(:link) }
+
+      its([:name]) { should eq(snapshots.name)}
+      its([:size]) { should eq(snapshots.size)}
+      its([:href]) { should eq(snapshots.href)}
+    end
+
+  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' } }
+
+      let(:volume) { Volume.load(volume_data) }
+      subject(:snapshots) { volume.snapshots }
+
+      it 'validates' do
+        expect(snapshots.validate).to be_empty
+      end
+
+      context 'with invalid attributes' do
+        let(:snapshots_data) { {name: 'notsnapshots',   href: '/bob/snapshots' } }
+        it 'returns the error' do
+          expect(snapshots.validate).to have(1).item
+          expect(snapshots.validate[0]).to match(/value \(notsnapshots\) does not match regexp/)
+        end
+      end
+    end
+
+    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 }
+      subject(:members) { snapshots.to_a }
+      
+      it 'validates' do
+        expect(snapshots.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(snapshots.validate).to have(1).item
+          expect(snapshots.validate[0]).to match(/value \(invalid-1\) does not match regexp/)
+        end
+      end
+    end
+  end
+
+end

data/spec/praxis/media_type_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Praxis::MediaType do
+  let(:owner_resource) { double('owner', id: 100, name: /[:name:]/.gen, href: '/') }
+  let(:manager_resource) { double('manager', id: 101, name: /[:name:]/.gen, href: '/') }
+
+  let(:resource) do
+    double('address', id: 1, name: 'Home',owner: owner_resource, manager: manager_resource)
+  end
+
+  subject(:address) { Address.new(resource) }
+
+  context 'attributes' do
+    its(:id)    { should eq(1) }
+    its(:name)  { should eq('Home') }
+    its(:owner) { should be_instance_of(Person) }
+
+    context 'links' do
+      it 'respects using' do
+        expect(address.links.super).to be_kind_of(Person)
+        expect(address.links.super.object).to be(resource.manager)
+      end
+    end
+  end
+
+  context 'accessor methods' do
+    subject(:address_klass) { address.class }
+
+    its(:identifier)  { should be_kind_of(String) }
+    its(:description) { should be_kind_of(String) }
+  end
+
+  context "rendering" do
+    subject(:output) { address.render(:default) }
+
+    its([:id])    { should eq(address.id) }
+    its([:name])  { should eq(address.name) }
+    its([:owner]) { should eq(Person.dump(owner_resource, view: :default)) }
+
+
+    context 'links' do
+      subject(:links) { output[:links] }
+
+      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
+        let(:volume) { Volume.example }
+        let(:snapshots) { volume.snapshots }
+        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) }
+      end
+    end
+
+
+  end
+
+  context '.example' do
+    subject(:example) { Address.example }
+
+    its('links.owner') { should be(example.owner) }
+    its('links.super') { should be(example.object.manager) }
+
+    it 'does not respond to non-top-level attributes from links' do
+      expect { example.super }.to raise_error(NoMethodError)
+    end
+
+    it 'responds to non-top-level attributes from links on its inner Struct' do
+      expect(example.links.super).to be(example.object.manager)
+    end
+  end
+
+  context 'using blueprint caching' do
+    it 'has specs'
+  end
+end

data/spec/praxis/multipart/parser_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Praxis::MultipartParser do
+
+  let(:form) do
+    form_data = MIME::Multipart::FormData.new
+
+    destination_path = MIME::Text.new('/etc/defaults')
+    form_data.add destination_path, 'destination_path'
+
+    form_data
+  end
+
+  let(:headers) { form.headers.headers }
+  let(:body) { form.body.to_s }
+
+  let(:parser) { Praxis::MultipartParser.new(headers, body) }
+
+  subject(:parts) { parser.parse[1] }
+
+  context 'with simple parts' do
+    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')
+    end
+  end
+
+  context 'with a file part' do
+    before do
+      text = MIME::Text.new('DOCKER_HOST=tcp://127.0.0.1:2375')
+      form.add text, 'file', 'docker'
+    end
+
+    subject(:file_part_body) { parts['file'].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/) } 
+
+    it 'saves the value to the tempfile' do
+      expect(File.exist?(file_part_body[:tempfile].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')
+    end
+
+  end
+
+end