praxis 0.0.1 → 0.9

data/spec/praxis/restful_routing_config_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Praxis::Skeletor::RestfulRoutingConfig do
+
+  let(:resource_definition) do
+    Class.new do
+      include Praxis::ResourceDefinition
+      def self.name; 'MyResource'; end
+    end
+  end
+
+  let(:action_name) { :index }
+  let(:routing_block) { Proc.new{} }
+  let(:default_route_prefix) { "/" + resource_definition.name.split("::").last.underscore }
+
+  subject(:routing_config){ Praxis::Skeletor::RestfulRoutingConfig.new(action_name, resource_definition, &routing_block) }
+
+  context "#initialize" do
+    it "name" do
+      expect(subject.name).to eq(:index)
+    end
+
+    it "resource_definition" do
+      expect(subject.resource_definition).to eq(resource_definition)
+    end
+
+    it "routes" do
+      expect(subject.routes.empty?).to eq(true)
+    end
+
+    it "prefix" do
+      expect(subject.prefix).to eq(default_route_prefix)
+    end
+  end
+
+  context "#add_route" do
+    let(:route_verb){ 'GET' }
+    let(:route_path){ '/path' }
+    let(:route_opts){ {option: 1} }
+
+    before(:each) do
+      routing_config.add_route(route_verb, route_path, route_opts)
+    end
+
+    it "routes" do
+      expect(subject.routes.length).to eq(1)
+    end
+
+    it "saves the verb and options into the route" do
+      route = subject.routes.first
+
+      expect(route.verb).to eq(route_verb)
+      expect(route.options).to eq(route_opts)
+    end
+
+    context "with a resource definition that does not have a route prefix" do
+      it 'saves the path with the default path prefix' do
+        path = subject.routes.first.path.to_s
+        expect(path).to eq(default_route_prefix + route_path)
+      end
+    end
+
+    context "with a resource definition that has a route prefix" do
+      let(:routing_block) { Proc.new{ prefix "/my_custom_route" } }
+      subject(:routing_config){ Praxis::Skeletor::RestfulRoutingConfig.new(action_name, resource_definition, &routing_block) }
+      it 'appends the prefix to the path' do
+        path = subject.routes.first.path.to_s
+        expect(path).to eq("/my_custom_route" + route_path)
+      end
+
+    end
+  end
+
+  context 'route helpers' do
+    let(:route_prefix) { nil }
+
+    it 'call the add_route with the correct parameters' do
+      helper_verbs = [:get, :put, :post, :delete, :head, :options, :patch ]
+      helper_verbs.each do |verb|
+        path = "/path_for_#{verb}"
+        options = {option: verb}
+        expect(subject).to receive(:add_route).with(verb.to_s.upcase,path,options)
+        subject.send(verb, path, options)
+      end
+    end
+  end
+
+end

data/spec/praxis/route_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Praxis::Route do
+
+  let(:verb) { 'GET' }
+  let(:path) { '/stuff' }
+  let(:name) { nil }
+  let(:version) { '1.0' }
+  let(:options) { {} }
+
+  subject(:route) { Praxis::Route.new(verb, path, version, name: name, **options) }
+
+  its(:verb) { should be(verb) }
+  its(:path) { should be(path) }
+  its(:name) { should be(name) }
+  its(:version) { should be(version) }
+  its(:options) { should eq(options) }
+
+  it 'defaults version to "n/a"' do
+    route = Praxis::Route.new(verb, path, name: name, **options)
+    expect(route.version).to eq('n/a')
+  end
+
+  context '#describe' do
+    subject(:description) { route.describe }
+    it { should eq({verb:verb, path:path , version:version}) }
+
+    context 'with a named route' do
+      let(:name) { :stuff }
+      its([:name]) { should eq(name) }
+    end
+
+    context 'with options' do
+      let(:options) { {option: 'value'} }
+      its([:options]) { should eq(options) }
+    end
+
+  end
+
+
+
+end

data/spec/praxis/router_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe Praxis::Router do
+  describe Praxis::Router::VersionMatcher do
+    let(:target){ double("target") }
+    let(:args){ {version: "1.0"} }
+    subject(:matcher){ Praxis::Router::VersionMatcher.new(target,args) }
+
+    context '.initialize' do
+      let(:args){ {} }
+      it 'defaults to no version' do
+        expect( matcher.instance_variable_get(:@version) ).to eq("n/a")
+      end
+    end
+    
+    context '.call' do
+      let(:env){ {"HTTP_X_API_VERSION" => request_version } }
+      let(:request) {Praxis::Request.new(env)}
+      
+      #let(:request){ double("request", version: request_version, env: env ) }
+      context 'with matching versions' do
+        let(:request_version) { "1.0" }
+        it 'calls the target' do
+          expect( target ).to receive(:call).with(request)
+          matcher.call(request)
+        end
+      end
+      context 'with non-matching versions' do
+        let(:request_version) { "4.0" }
+        before do
+          expect { matcher.call(request) }.to throw_symbol(:pass)
+        end
+        it 'does not call the target' do
+          expect( target ).not_to receive(:call).with(request)
+        end
+        it 'saves the unmatched version' do
+          expect( request.unmatched_versions ).to include(args[:version])
+        end
+      end
+
+    end
+  end
+  describe Praxis::Router::RequestRouter do
+
+    let(:request) {double("request", route_params: '', path: 'path')}
+    let(:callback) {double("callback")}
+  
+    subject(:request_router) {Praxis::Router::RequestRouter.new}
+    
+    context ".invoke" do
+      it "update request and call request for callback" do
+        allow(request).to receive(:route_params=)
+        allow(callback).to receive(:call).and_return(1)
+
+        invoke_call = request_router.invoke(callback, request, "params", "pattern")
+        expect(invoke_call).to eq(1)
+      end
+    end
+
+    context ".string_for" do
+      it "returns request path string" do
+        expect(request_router.string_for(request)).to eq('path')
+      end
+    end
+  end
+
+  let(:application) { instance_double('Praxis::Application')}
+  subject(:router) {Praxis::Router.new(application)}
+
+  context "attributes" do
+    its(:request_class) {should be(Praxis::Request)}
+  end
+
+  context ".add_route" do
+    let(:route){ double('route', options: [1], version: 1, verb: 'verb', path: 'path')}
+    let(:target){ double('target') }
+    let(:verb_router){ double('verb_router') }
+    it 'wraps the target with a VersionMatcher' do
+      router.instance_variable_set( :@routes, {'verb'=>verb_router} ) # Ugly, but no need to have a reader
+      expect(verb_router).to receive(:on) do|path, args|# .with(route.path, call: "foo")
+        expect(path).to eq(route.path)
+        expect(args).to be_kind_of(Hash)
+        expect(args[:call]).to be_kind_of(Praxis::Router::VersionMatcher)
+      end
+      router.add_route(target ,route)
+    end
+    
+    it "raises warning when options are specified in route" do
+      expect(router).to receive(:warn).with("other conditions not supported yet")
+      expect(router.add_route(proc {'target'},route)).to eq(['path'])
+    end
+  end
+
+  context ".call" do
+    let(:env){ {} }
+    let(:request_version){ nil }
+    let(:request) {Praxis::Request.new(env)}
+    let(:router_response){ 1 }
+    
+    before do
+      request.instance_variable_set(:@version,request_version) if request_version
+      allow_any_instance_of(Praxis::Router::RequestRouter).
+        to receive(:call).with(request).and_return(router_response)
+    end
+    
+    it "calls the route with params request" do
+      expect(router.call(request)).to eq(router_response)
+    end
+    
+    context "when not_found is returned" do
+      let(:router_response){ :not_found }
+      before{ request.instance_variable_set(:@unmatched_versions, unmatched_versions) }
+
+      context "having passed no version in the request" do
+        
+        context 'and no controllers matching the path' do
+          let(:unmatched_versions){ Set.new([]) }
+          it 'returns a basic "NotFound" response: 404 status, text/plain content and "NotFound" body' do
+            expect( router.call(request) ).to eq([404, {"Content-Type" => "text/plain", }, ["NotFound"]])
+          end
+        end
+        
+        context 'and some controllers matching the path' do
+          let(:unmatched_versions){ Set.new(["1.0"]) }          
+          it 'returns a specific body response noting which request versions would matched if passed in' do
+            _, _, body = router.call(request)
+            expect( body.first ).to eq('NotFound. Your request did not specify an API version. Available versions = "1.0".')
+          end
+        end
+      end
+      
+      context "having passed a version in the request" do
+        
+        context 'but having no controllers matching the path part' do
+          let(:request_version){ "50.0" }
+          let(:unmatched_versions){ Set.new(["1.0","2.0"]) }          
+          
+          it 'returns a specific body response noting that the version might be wrong (and which could be right)' do
+            code, headers, body = router.call(request)
+            expect(code).to eq(404)
+            expect(headers['Content-Type']).to eq('text/plain')
+            expect(body.first).to eq("NotFound. Your request speficied API version = \"#{request_version}\". Available versions = \"1.0\", \"2.0\".")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/praxis/stage_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Praxis::Stage do
+  subject(:stage) {Praxis::Stage.new("name","context")}
+
+  context "attributes" do
+    its(:name) {should eq("name")}
+    its(:context) {should eq("context")}
+    its(:stages) {should eq([])}
+    its(:before_callbacks) {should eq([])}
+    its(:after_callbacks) {should eq([])}
+  end
+
+  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
+    end
+  end
+
+  context ".setup!" do
+    it "should do something"
+  end
+
+  context ".setup_deferred_callbacks!" do
+    it "calls .before and .after for each stage name in @deferred_callbacks" do
+      deferred_callbacks = {
+        "stage" => {
+          :before => [["before",nil]],
+          :after  => [["after",nil]]
+        }}
+      stage.instance_variable_set("@deferred_callbacks", deferred_callbacks)
+      expect(stage).to receive("before")
+      expect(stage).to receive("after")
+      stage.setup_deferred_callbacks!
+    end
+  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')
+      stage.instance_variable_set("@stages", [double_stage])
+      stage.execute
+    end
+  end
+
+  context ".execute_callbacks" do
+    let(:callback) {double('callback')}
+    it "executes every callback" do
+      expect(callback).to receive("call")
+      stage.execute_callbacks([callback])
+    end
+  end
+
+  context ".callback_args" do
+    # TODO should this method return something else than nil?
+    it "returns nil" do
+      expect(stage.callback_args).to be(nil)
+    end
+  end
+
+  context ".before" do
+    it "adds block to @before_callbacks when stage_path is not provided" do
+      stage.before {1}
+      expect(stage.before_callbacks.last.call).to be(1)
+    end
+
+    it "calls .before for the name matched stage" do
+      double_stage = double("stage", name: "name")
+      expect(double_stage).to receive('before')
+      stage.instance_variable_set("@stages", [double_stage])
+      stage.before("name")
+    end
+
+    it "adds to deferred_callbacks if no state name matched" do
+      double_stage = double("stage", name: "name")
+      stage.instance_variable_set("@stages", [double_stage])
+      expect(stage.before("hello", "world")).to eq([["world",nil]])
+    end
+  end
+
+  context ".after" do
+    it "adds block to @after_callbacks when stage_path is not provided" do
+      stage.after {1}
+      expect(stage.after_callbacks.last.call).to be(1)
+    end
+
+    it "calls .after for the name matched stage" do
+      double_stage = double("stage", name: "name")
+      expect(double_stage).to receive("after")
+      stage.instance_variable_set("@stages", [double_stage])
+      stage.after("name")
+    end
+
+    it "adds to deferred_callbacks if no state name matched" do
+      double_stage = double("stage", name: "name")
+      stage.instance_variable_set("@stages", [double_stage])
+      expect(stage.after("hello", "world")).to eq([["world",nil]])
+    end
+  end
+end

data/spec/praxis/types/multipart_spec.rb

@@ -0,0 +1,81 @@
+require "spec_helper"
+
+describe Praxis::Multipart do
+  let(:type) { Praxis::Multipart }
+
+  let(:form) do
+    form_data = MIME::Multipart::FormData.new
+    entity = MIME::Text.new('1')
+    form_data.add entity,'some_name'
+    form_data
+  end
+
+  let(:content_type) { form.headers.get('Content-Type') }
+  let(:body) { form.body.to_s }
+
+  subject(:multipart) { type.load(body, content_type: content_type) }
+
+  context 'with no block' do
+    its(:parts) { should have(1).item }
+    its(['some_name']) { should eq('1') }
+  end
+
+  context 'with value type' do
+    let(:type) { Praxis::Multipart.of(value: Integer) }
+    its(['some_name']) { should eq(1) }
+  end
+
+
+  context 'with a block' do
+
+    let(:block) do
+      proc do
+        key 'some_name', Integer
+        key 'some_date', DateTime
+      end
+    end
+
+    let(:date) { DateTime.parse("2014-07-15") }
+
+    before do
+      entity = MIME::Text.new(date)
+      form.add entity,'some_date'
+    end
+
+    let(:type) { Praxis::Multipart.construct(block) }
+
+    its(['some_name']) { should eq(1) }
+    its(['some_date']) { should eq(date) }
+
+  end
+
+
+  context 'with a preamble' do
+    let(:preamble) { "some preamble"}
+    let(:body) { preamble + "\r\n" + form.body.to_s }
+
+    it 'preserves the value' do
+      expect(multipart.preamble).to eq(preamble)
+    end
+
+  end
+
+  context '.example' do
+    let(:type) { Praxis::Multipart.of(value: Instance) }
+    subject(:example) { type.example('example') }
+
+    it 'generates an interesting example' do
+      expect(example.keys.all? { |k| k.kind_of? String }).to be(true)
+      expect(example.values.all? { |k| k.kind_of? Instance }).to be(true)
+      expect(example.parts.keys).to eq(example.keys.collect(&:to_s))
+
+
+      instance = Instance.load(example.parts.first.last.body)
+      expect(instance.validate).to be_empty
+
+      expect(example.headers['Content-Type']).to match(/multipart\/form-data; boundary=/)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,63 @@
+class Instances
+  include Praxis::Controller
+
+  implements ApiResources::Instances
+
+  before :validate, actions: [:index]  do |controller|
+    #p [:before, :validate, :params_and_headers, controller.request.action.name]
+  end
+
+  before actions: [:show] do
+    #puts "before action"
+  end
+
+  def index(response_content_type:, **params)
+    response.headers['Content-Type'] = response_content_type #'application/vnd.acme.instance;type=collection'
+    JSON.generate(params)
+  end
+
+  def show(cloud_id:, id:, junk:, **other_params)
+    payload = request.payload
+    response.body = {cloud_id: cloud_id, id: id, junk: junk, other_params: other_params, payload: payload.dump}
+    response.headers['Content-Type'] = 'application/vnd.acme.instance'
+    response
+  end
+
+  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.action(:show).primary_route.path.expand(cloud_id: cloud_id, id: instance.id)
+      }
+
+      part = Praxis::MultipartPart.new(part_body, headers)
+
+      response.add_part(instance_id, part)
+    end
+
+    response
+  end
+
+
+  def attach_file(id:, cloud_id:)
+    response.headers['Content-Type'] = 'application/json'
+
+    destination_path = request.payload['destination_path']
+    file = request.payload['file']
+
+    result = {
+      destination_path: destination_path,
+      file: file.dump
+    }
+
+    response.body = JSON.pretty_generate(result)
+
+    response
+  end
+
+
+end

data/spec/spec_app/app/responses/bulk_response.rb

@@ -0,0 +1,6 @@
+
+class BulkResponse < Praxis::Response
+  self.response_name = :bulk_response
+  self.status = 200
+end
+

data/spec/spec_app/app/responses/multipart.rb

@@ -0,0 +1,10 @@
+
+class MultipartResponse < Praxis::Response
+  self.response_name = :multipart
+
+  def handle
+    @status = 200
+  end
+
+end
+

data/spec/spec_app/app/responses/other_response.rb

@@ -0,0 +1,6 @@
+class OtherResponse < Praxis::Response
+  self.response_name = :other_response
+  self.status = 200
+
+end
+

data/spec/spec_app/config/environment.rb

@@ -0,0 +1,17 @@
+Praxis::Application.configure do |application|
+  application.layout do
+    layout do
+      map :initializers, 'config/initializers/**/*'
+      map :design, 'design/' do
+        map :api, 'api.rb'
+        map :media_types, '**/media_types/**/*'
+        map :resources, '**/resources/**/*'        
+      end
+      map :app, 'app/' do
+        map :models, 'models/**/*'
+        map :controllers, '**/controllers/**/*'
+        map :responses, '**/responses/**/*'
+      end
+    end
+  end
+end

data/spec/spec_app/config.ru

@@ -0,0 +1,17 @@
+require 'pp'
+require 'json'
+
+require 'bundler/setup'
+
+require 'pry'
+
+$:.unshift File.expand_path('lib', __dir__)
+
+require 'praxis'
+
+
+application = Praxis::Application.instance
+
+application.setup
+
+run application

data/spec/spec_app/design/api.rb

@@ -0,0 +1,27 @@
+Praxis::ApiDefinition.define do
+
+  response_template :other_response do |media_type:|
+    status 200
+    media_type media_type
+  end
+
+  response_template :multipart do
+    status 200
+    media_type 'multipart/form-data'
+  end
+
+  response_template :bulk_response do |media_type:, parts: |
+    status 200
+    media_type 'multipart/form-data'
+
+    parts[:media_type] ||= media_type if parts.kind_of? Hash
+    parts(parts)
+  end
+
+  trait :authenticated do
+    headers do
+      header :host
+    end
+  end
+
+end

data/spec/spec_app/design/media_types/instance.rb

@@ -0,0 +1,35 @@
+class Instance < Praxis::MediaType
+
+  identifier 'application/vnd.acme.instance'
+
+  attributes do
+    attribute :id, Integer
+    attribute :name, String, example: /[:first_name:]/
+
+    attribute :href, String
+
+    attribute :root_volume, Volume
+
+    links do
+      link :root_volume
+      link :other_volume, Volume, using: :data_volume
+    end
+  end
+
+  view :default do
+    attribute :id
+    attribute :root_volume
+    attribute :links
+  end
+
+  view :link do
+    attribute :id
+    attribute :href
+  end
+
+  view :create do
+    attribute :id
+    attribute :name
+  end
+
+end

data/spec/spec_app/design/media_types/volume.rb

@@ -0,0 +1,34 @@
+class Volume < Praxis::MediaType
+  identifier 'application/json'
+
+  attributes do
+    attribute :id, Integer
+    attribute :name, String
+
+    attribute :source, VolumeSnapshot
+
+    # returns VolumeSnapshot::Collection if exists
+    attribute :snapshots, Praxis::Collection.of(VolumeSnapshot)
+
+    links do
+      link :source
+      link :snapshots
+    end
+
+  end
+
+  view :default do
+    attribute :id
+    attribute :name
+    attribute :source
+    attribute :snapshots
+    attribute :links
+  end
+
+  view :link do
+    attribute :id
+  end
+
+end
+
+