praxis 0.0.1 → 0.9

data/lib/praxis.rb

@@ -1 +1,119 @@
-# Move along...nothing to see here yet
+require 'rack'
+require 'attributor'
+require 'praxis-mapper'
+require 'praxis-blueprints'
+
+$:.unshift File.dirname(__FILE__)
+
+module Attributor
+  class DSLCompiler
+    def use(name)
+      unless Praxis::ApiDefinition.instance.traits.has_key? name
+        raise Exceptions::InvalidTrait.new("Trait #{name} not found in the system")
+      end
+      self.instance_eval(&Praxis::ApiDefinition.instance.traits[name])
+    end
+  end
+end
+
+require 'mime'
+module MIME
+  class Header
+    attr_reader :headers
+  end
+end
+
+module Praxis
+  autoload :ActionDefinition, 'praxis/action_definition'
+  autoload :ApiDefinition, 'praxis/api_definition'
+  autoload :Application, 'praxis/application'
+  autoload :Bootloader, 'praxis/bootloader'
+  autoload :Config, 'praxis/config'
+  autoload :Controller, 'praxis/controller'
+  autoload :Dispatcher, 'praxis/dispatcher'
+  autoload :Exception, 'praxis/exception'
+  autoload :FileGroup,'praxis/file_group'
+  autoload :Plugin, 'praxis/plugin'
+  autoload :Request, 'praxis/request'
+  autoload :ResourceDefinition, 'praxis/resource_definition'
+  autoload :Response, 'praxis/response'
+  autoload :ResponseDefinition, 'praxis/response_definition'
+  autoload :ResponseTemplate, 'praxis/response_template'
+  autoload :Route, 'praxis/route'
+  autoload :Router, 'praxis/router'
+  autoload :SimpleMediaType, 'praxis/simple_media_type'
+  autoload :Stage, 'praxis/stage'
+  autoload :ContentTypeParser, 'praxis/content_type_parser'
+
+  # types
+  autoload :Links, 'praxis/links'
+  autoload :MediaType, 'praxis/media_type'
+  autoload :MediaTypeCollection, 'praxis/media_type_collection'
+  autoload :Multipart, 'praxis/types/multipart'
+  autoload :Collection, 'praxis/types/collection'
+
+  autoload :MultipartParser, 'praxis/multipart/parser'
+  autoload :MultipartPart, 'praxis/multipart/part'
+
+  class ActionDefinition
+    autoload :HeadersDSLCompiler, 'praxis/action_definition/headers_dsl_compiler'
+  end
+
+  module Exceptions
+    autoload :Config, 'praxis/exceptions/config'
+    autoload :ConfigLoad, 'praxis/exceptions/config_load'
+    autoload :ConfigValidation, 'praxis/exceptions/config_validation'
+    autoload :InvalidConfiguration, 'praxis/exceptions/invalid_configuration'
+    autoload :InvalidTrait, 'praxis/exceptions/invalid_trait'
+    autoload :InvalidResponse, 'praxis/exceptions/invalid_response'
+    autoload :StageNotFound, 'praxis/exceptions/stage_not_found'
+    autoload :Validation, 'praxis/exceptions/validation'
+  end
+
+  module Responses
+    autoload :Ok, 'praxis/responses/http'
+    autoload :Created, 'praxis/responses/http'
+    autoload :Accepted, 'praxis/responses/http'
+    autoload :NoContent, 'praxis/responses/http'
+    autoload :MultipleChoices, 'praxis/responses/http'
+    autoload :MovedPermanently, 'praxis/responses/http'
+    autoload :Found, 'praxis/responses/http'
+    autoload :SeeOther, 'praxis/responses/http'
+    autoload :NotModified, 'praxis/responses/http'
+    autoload :TemporaryRedirect, 'praxis/responses/http'
+    autoload :BadRequest, 'praxis/responses/http'
+    autoload :Unauthorized, 'praxis/responses/http'
+    autoload :Forbidden, 'praxis/responses/http'
+    autoload :NotFound, 'praxis/responses/http'
+    autoload :MethodNotAllowed, 'praxis/responses/http'
+    autoload :NotAcceptable, 'praxis/responses/http'
+    autoload :Conflict, 'praxis/responses/http'
+    autoload :PreconditionFailed, 'praxis/responses/http'
+    autoload :UnprocessableEntity, 'praxis/responses/http'
+    autoload :InternalServerError, 'praxis/responses/http'
+
+    autoload :ValidationError, 'praxis/responses/validation_error'
+  end
+
+  module BootloaderStages
+    autoload :FileLoader, 'praxis/bootloader_stages/file_loader'
+    autoload :Environment, 'praxis/bootloader_stages/environment'
+    autoload :SubgroupLoader, 'praxis/bootloader_stages/subgroup_loader'
+    autoload :WarnUnloadedFiles, 'praxis/bootloader_stages/warn_unloaded_files'
+    autoload :Routing, 'praxis/bootloader_stages/routing'
+  end
+
+  module RequestStages
+    autoload :RequestStage, 'praxis/request_stages/request_stage'
+    autoload :LoadRequest, 'praxis/request_stages/load_request'
+    autoload :Validate, 'praxis/request_stages/validate'
+    autoload :ValidateParamsAndHeaders, 'praxis/request_stages/validate_params_and_headers'
+    autoload :ValidatePayload, 'praxis/request_stages/validate_payload'
+    autoload :Action, 'praxis/request_stages/action'
+    autoload :Response, 'praxis/request_stages/response'
+  end
+
+  module Skeletor
+    autoload :RestfulRoutingConfig, 'praxis/skeletor/restful_routing_config'
+  end
+end

data/praxis.gemspec

@@ -0,0 +1,50 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'praxis/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "praxis"
+  spec.version       = Praxis::VERSION
+  spec.authors = ["Josep M. Blanquer","Dane Jensen"]
+  spec.date = "2014-08-19"
+  spec.summary = 'Building APIs the way you want it.'
+
+  spec.email = ["blanquer@gmail.com","dane.jensen@gmail.com"]
+
+  spec.homepage = "https://github.com/rightscale/praxis"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">=2.1"
+
+  spec.require_paths = ["lib"]
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.bindir = 'bin'
+  spec.executables << 'praxis'
+
+  spec.add_dependency 'rack', '~> 1'
+  spec.add_dependency 'mustermann', '~> 0'
+  spec.add_dependency 'activesupport', '~> 4'
+  spec.add_dependency 'ruport', '~> 1'
+  spec.add_dependency 'mime', '~> 0'
+  spec.add_dependency 'praxis-mapper', '~> 3.1'
+  spec.add_dependency 'praxis-blueprints', '~> 1.0'
+  spec.add_dependency 'attributor', '~> 2'
+  spec.add_dependency 'thor', '~> 0'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 0.9'
+  spec.add_development_dependency 'rake-notes', '~> 0'
+  spec.add_development_dependency 'pry', '~> 0'
+  spec.add_development_dependency 'pry-byebug', '~> 1'
+  spec.add_development_dependency 'pry-stack_explorer', '~> 0'
+  spec.add_development_dependency 'rspec', '~> 3'
+  spec.add_development_dependency 'rspec-its', '~> 1'
+  spec.add_development_dependency 'rspec-collection_matchers', '~> 1'
+  spec.add_development_dependency 'guard', '~> 2'
+  spec.add_development_dependency 'guard-rspec', '~> 4'
+  spec.add_development_dependency 'guard-bundler', '~> 2'
+  spec.add_development_dependency 'rack-test', '~> 0'
+  spec.add_development_dependency 'simplecov', '~> 0'
+  spec.add_development_dependency 'fuubar', '~> 2'
+  spec.add_development_dependency 'yard', '~> 0'
+end

data/spec/functional_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe 'Functional specs' , focus: true do
+
+  def app
+    Praxis::Application.instance
+  end
+
+  context 'index' do
+    context 'with an incorrect response_content_type param' do
+      it 'fails to validate the response' do
+        get '/clouds/1/instances?response_content_type=somejunk&api_version=1.0'
+        response = JSON.parse(last_response.body)
+        expect(response['name']).to eq('Praxis::Exceptions::Validation')
+        expect(response["message"]).to match(/Bad Content-Type/)
+      end
+
+      context 'with response validation disabled' do
+        let(:praxis_config) { double('praxis_config', validate_responses: false) }
+        let(:config) { double('config', praxis: praxis_config) }
+
+        before do
+          expect(Praxis::Application.instance.config).to receive(:praxis).and_return(praxis_config)
+        end
+        
+        it 'fails to validate the response' do
+          expect {
+            get '/clouds/1/instances?response_content_type=somejunk&api_version=1.0'
+          }.to_not raise_error
+        end
+
+      end
+    end
+
+  end
+
+  it 'works' do
+    get '/clouds/1/instances/2?junk=foo&api_version=1.0'
+    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"}, "payload"=>{"something"=>nil, "optional"=>"not given"}})
+    expect(last_response.headers).to eq({"Content-Type"=>"application/vnd.acme.instance", "Content-Length"=>"188"})
+  end
+
+
+  context 'bulk_create multipart' do
+
+    let(:instance) { Instance.example }
+    let(:instance_json) { JSON.pretty_generate(instance.render(:create)) }
+
+    let(:form) do
+      form_data = MIME::Multipart::FormData.new
+      entity = MIME::Text.new(instance_json)
+      form_data.add entity, instance.id.to_s
+      form_data
+    end
+
+    let(:content_type) { form.headers.get('Content-Type') }
+    let(:body) { form.body.to_s }
+
+    it 'works' do
+      post '/clouds/1/instances?api_version=1.0', body, 'CONTENT_TYPE' => content_type
+
+      _reponse_preamble, response = Praxis::MultipartParser.parse(last_response.headers, last_response.body)
+      expect(response).to have(1).item
+
+      response_id, instance_part = response.first
+      expect(response_id).to eq(instance.id.to_s)
+
+      instance_headers = instance_part.headers
+      expect(instance_headers['Status']).to eq('201')
+      expect(instance_headers['Location']).to match(%r|/clouds/.*/instances/.*|)
+
+      response_instance = JSON.parse(instance_part.body)
+      expect(response_instance["key"]).to eq(instance.id)
+      expect(response_instance["value"].values).to eq(instance.render(:create).values)
+    end
+  end
+
+
+  context 'attach_file' do
+    let(:form) do
+      form_data = MIME::Multipart::FormData.new
+
+      destination_path = MIME::Text.new('/etc/defaults')
+      form_data.add destination_path, 'destination_path'
+
+      text = MIME::Text.new('DOCKER_HOST=tcp://127.0.0.1:2375')
+      form_data.add text, 'file', 'docker'
+
+      form_data
+    end
+
+    let(:content_type) { form.headers.get('Content-Type') }
+    let(:body) { form.body.to_s }
+
+    context 'with a valid payload' do
+      before do
+        post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type
+      end
+
+      subject(:response) { JSON.parse(last_response.body) }
+
+      its(['destination_path']) { should eq '/etc/defaults' }
+
+      context 'response["file"]' do
+        subject(:file) { response['file'] }
+
+        its(['filename']) { should eq('docker') }
+        its(['type']) { should eq('text/plain') }
+        its(['name']) { should eq('file') }
+        its(['tempfile']) { should match(/^\//) }
+      end
+    end
+
+    context 'with unknown key in form' do
+      before do
+        junk = MIME::Text.new('junk_value')
+        form.add junk, 'junk_name'
+      end
+
+      it 'returns an error' do
+        post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type
+        response = JSON.parse(last_response.body)
+        expect(response['name']).to eq('ValidationError')
+        expect(response["message"]).to match(/Unknown key received:/)
+      end
+
+    end
+
+    context 'with a missing value in form' do
+      let(:form) do
+        form_data = MIME::Multipart::FormData.new
+
+        text = MIME::Text.new('DOCKER_HOST=tcp://127.0.0.1:2375')
+        form_data.add text, 'file', 'docker'
+
+        form_data
+      end
+
+      let(:body) { form.body.to_s }
+      
+      it 'returns an error' do
+        post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type
+        response = JSON.parse(last_response.body)
+
+        expect(response['name']).to eq('ValidationError')
+        expect(response['errors']).to eq(["Attribute $.payload.get(\"destination_path\") is required"])
+      end
+
+    end
+
+  end
+
+
+  context 'not found and API versions' do
+    context 'when no version is speficied' do
+      it 'it tells you which available api versions would match' do
+        get '/clouds/1/instances/2?junk=foo'
+        
+        expect(last_response.status).to eq(404)
+        expect(last_response.headers["Content-Type"]).to eq("text/plain")
+        expect(last_response.body).to eq("NotFound. Your request did not specify an API version. Available versions = \"1.0\".")
+      end
+      it 'it just gives you a simple not found when nothing would have matched' do
+        get '/foobar?junk=foo'
+        
+        expect(last_response.status).to eq(404)
+        expect(last_response.headers["Content-Type"]).to eq("text/plain")
+        expect(last_response.body).to eq("NotFound")
+      end
+    end
+
+    context 'when some version is speficied, but wrong' do
+      it 'it tells you which possible correcte api versions exist' do
+        get '/clouds/1/instances/2?junk=foo&api_version=50.0'
+        
+        expect(last_response.status).to eq(404)
+        expect(last_response.headers["Content-Type"]).to eq("text/plain")
+        expect(last_response.body).to eq("NotFound. Your request speficied API version = \"50.0\". Available versions = \"1.0\".")
+      end
+    end
+
+    
+  end
+
+end

data/spec/praxis/action_definition_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe Praxis::ActionDefinition do
+  let(:resource_definition) do
+    Class.new do
+      include Praxis::ResourceDefinition
+
+      def self.name
+        'FooBar'
+      end
+
+      media_type 'application/json'
+      version '1.0'
+      routing { prefix '/api/hello_world' }
+      payload { attribute :inherited, String }
+      headers { header :inherited, String }
+      params  { attribute :inherited, String }
+    end
+  end
+
+  subject(:action) do
+    described_class.new('foo', resource_definition) do
+      routing { get '/:one' }
+      payload { attribute :two, String }
+      headers { header :X_REQUESTED_WITH, 'XMLHttpRequest' }
+      params  { attribute :one, String }
+    end
+  end
+
+  context '#initialize' do
+    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 }
+    its('payload.attributes')  { should have_key :two }
+    its('payload.attributes')  { should have_key :inherited }
+    its('headers.attributes')  { should have_key :X_REQUESTED_WITH }
+    its('headers.attributes')  { should have_key :INHERITED }
+  end
+
+  context '#responses' do
+    subject(:responses) { action.responses }
+    before do
+      action.response :ok
+      action.response :internal_server_error
+    end
+    
+    it { should be_kind_of Hash }
+    it { should include :ok }
+    it { should include :internal_server_error }
+  end
+
+  describe '#allowed_responses' do
+    it 'has some tests after we stop using ApiDefinition.instance'
+  end
+
+  describe '#use' do
+    it 'has some tests after we stop using ApiDefinition.instance'
+  end
+
+  describe '#params' do
+    it 'merges in more params' do
+      subject.params do
+        attribute :more, Attributor::Integer
+      end
+
+      expect(subject.params.attributes.keys).to match_array([
+        :one, :inherited, :more
+      ])
+    end
+  end
+
+  describe '#payload' do
+    it 'merges in more payload' do
+      subject.payload do
+        attribute :more, Attributor::Integer
+      end
+
+      expect(subject.payload.attributes.keys).to match_array([
+        :two, :inherited, :more
+      ])
+    end
+  end
+
+  describe '#headers' do
+    it 'merges in more headers' do
+      subject.headers do
+        header :more
+      end
+
+      expect(subject.headers.attributes.keys).to match_array([
+        :X_REQUESTED_WITH, :INHERITED, :MORE
+      ])
+    end
+  end
+
+  describe '#routing' do
+    it 'has some tests when Skeletor::RestfulRoutingConfig disappears'
+  end
+
+  context '#description' do
+    it 'sets and returns the description' do
+      subject.description('weeeeee')
+      expect(subject.description).to eq 'weeeeee'
+    end
+  end
+
+  context '#describe' do
+    it 'has some tests when Skeletor::RestfulRoutingConfig disappears'
+  end
+
+  context 'href generation' do
+    let(:resource_definition) { ApiResources::Instances }
+    subject(:action) { resource_definition.actions[:show] }
+
+    it 'works' do
+      expansion = action.primary_route.path.expand(cloud_id:232, id: 2)
+      expect(expansion).to eq "/clouds/232/instances/2"
+    end
+
+    context '#primary_route' do
+      it 'is the first-defined route' do
+        expect(action.primary_route).to be(action.routes.first)
+      end
+    end
+
+    context '#named_routes' do
+      subject(:named_routes) { action.named_routes }
+
+      its([:alternate]) { should be(action.routes[1]) }
+    end
+
+  end
+end

data/spec/praxis/application_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Praxis::Application do
+  describe 'configuration' do
+    subject(:app) do
+      app = Class.new(Praxis::Application).instance
+
+      config = Object.new
+      def config.define(key=nil, type=Attributor::Struct, **opts, &block)
+        return [key,type,opts,block]
+      end
+      def config.get
+        return 'gotconfig'
+      end
+      def config.set(config)
+        return config
+      end
+      app.instance_variable_set(:@config, config)
+      app
+    end
+
+    describe '#config' do
+      let(:myblock){ lambda {} }
+      it 'passes the block to config (and sets the right defaults)' do
+        ret = app.config(&myblock)
+        expect(ret).to eq([nil,Attributor::Struct,{},myblock])
+      end
+
+      it 'passes the params and block to config' do
+        ret = app.config(:key, Attributor::Hash, {option: :one}, &myblock)
+        expect(ret).to eq([:key, Attributor::Hash, {option: :one}, myblock])
+      end
+
+      it 'gets config with no block given' do
+        expect(app.config).to eq('gotconfig')
+      end
+    end
+
+    describe '#config=' do
+      it 'sets config' do
+        ret = (app.config = 'someconfig')
+        expect(ret).to eq 'someconfig'
+      end
+    end
+  end
+end

data/spec/praxis/bootloader_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Praxis::Bootloader do
+  let(:application) do
+    instance_double("Praxis::Application", config: "config", root: "root", plugins: [])
+  end
+
+  subject(:bootloader) {Praxis::Bootloader.new(application)}
+
+  context 'attributes' do
+    its(:application) {should be(application)}
+    it 'stages' do
+      init_stages = [:environment, :initializers, :lib, :design, :app, :routing, :warn_unloaded_files]
+      expect(bootloader.stages.map {|s| s.name}).to eq(init_stages)
+    end
+    its(:config) {should be(application.config)}
+    its(:root) {should be(application.root)}
+  end
+
+  context ".delete_stage" do
+    it "delete valid stage" do
+      bootloader.delete_stage(:app)
+      expect(bootloader.stages.include?(:app)).to be(false)
+    end
+
+    it "raise errors when deleting invalid stage" do
+      expect{bootloader.delete_stage(:unexistent_stage)}.to raise_error(Praxis::Exceptions::StageNotFound)
+    end
+  end
+
+  context ".before" do
+    it "run before block of first element in stage_path" do
+      stage = bootloader.stages.first
+      allow(stage).to receive(:before).and_return('before!')
+      expect(bootloader.before(stage.name)).to eq('before!')
+    end
+
+    it "raises when given an invalid stage name"
+  end
+
+  context ".after" do
+    it "run before block of first element in stage_path" do
+      stage = bootloader.stages.first
+      allow(stage).to receive(:after).and_return('after!')
+      expect(bootloader.after(stage.name)).to eq('after!')
+    end
+
+    it "raises when given an invalid stage name"
+  end
+
+  context ".use" do
+    it "plugin add to application" do
+      bootloader.use(Praxis::Plugin)
+      new_plugin = Praxis::Plugin.new(bootloader.application)
+      expect(bootloader.application.plugins.last.class).to be(Praxis::Plugin)
+    end
+  end
+end