zero 0.1.0

data/spec/unit/controller/call_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Zero::Controller, '.call' do
+  subject { SpecController.call(env) }
+  let(:env) { EnvGenerator.get('/foo') }
+
+  it "returns a response" do
+    subject.should be_respond_to(:to_a)
+  end
+
+  it "returns an object with the first element being a status" do
+    subject[0].should be_kind_of(Numeric)
+  end
+
+  it "does not modify an existing request" do
+    r = Zero::Request.new(env)
+    r.params['foo'] = 'bar'
+    subject
+    r = Zero::Request.create(env)
+    expect(r.params['foo']).to eq('bar')
+  end
+end

data/spec/unit/controller/renderer_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Zero::Controller, '#renderer' do
+  subject { Zero::Controller }
+  let(:renderer) { Object.new }
+  
+  it 'returns the set renderer' do
+    subject.renderer = renderer
+    expect(subject.new(Object.new).renderer).to be(renderer)
+  end
+end

data/spec/unit/renderer/read_template_path_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Zero::Renderer, 'read_template_path!' do
+  subject { Zero::Renderer.new(template_path, type_map) }
+  let(:template_path) { 'foo' }
+  let(:file_list) { ['foo/welcome/index.html.erb'] }
+
+  before :each do
+    subject.stub(:search_files).and_return(file_list)
+  end
+
+  shared_examples_for 'a template loader' do
+    it 'creates a template tree' do
+      subject.read_template_path!
+      subject.templates['welcome/index'].should eq(result)
+    end
+  end
+
+  context 'without mapping' do
+    let(:type_map) { {} }
+    let(:result) { { 'html' => 'foo/welcome/index.html.erb' } }
+
+    it_behaves_like 'a template loader'
+  end
+
+  context 'with a single mapping' do
+    let(:type_map) { {'html' => 'text/html' } }
+    let(:result) { { 'text/html' => 'foo/welcome/index.html.erb' } }
+
+    it_behaves_like 'a template loader'
+  end
+
+  context 'with multiple mappings' do
+    let(:type_map) { {'html' => ['text/html', 'text/xml'] } }
+    let(:result) { {
+      'text/html' => 'foo/welcome/index.html.erb',
+      'text/xml'  => 'foo/welcome/index.html.erb'
+    } }
+
+    it_behaves_like 'a template loader'
+  end
+
+  context 'with default template' do
+    let(:file_list) {['foo/welcome/index.erb']}
+    let(:type_map) { {'default' => ['text/html', 'text/xml'] } }
+    let(:result) { {
+      'text/html' => 'foo/welcome/index.erb',
+      'text/xml'  => 'foo/welcome/index.erb'
+    } }
+
+    it_behaves_like 'a template loader'
+  end
+end

data/spec/unit/renderer/render_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Zero::Renderer, '#render' do
+  subject { Zero::Renderer.new(template_path, type_map) }
+  let(:template_path) { 'spec/fixtures/templates' }
+  let(:file_list) { ['./foo/welcome/index.html.erb'] }
+  let(:type_map) {{
+    'html' => ['text/html', 'text/xml', '*/*'],
+    'json' => ['application/json', 'plain/text']
+  }}
+  let(:html_types) { ['text/html'] }
+  let(:json_types) { ['application/json'] }
+  let(:foo_types)  { ['foo/bar', 'bar/foo'] }
+  let(:binding) { SpecTemplateContext.new('foo') }
+
+  before :each do
+    subject.read_template_path!
+  end
+
+  it 'returns a tilt template' do
+    subject.render('index', html_types, binding).should be_kind_of(String)
+  end
+
+  it 'renders html content' do
+    subject.render('index', html_types, binding).should match('success')
+  end
+
+  it 'returns a tilt template for different types' do
+    subject.render('index', json_types, binding).should be_kind_of(String)
+  end
+
+  it 'renders json content' do
+    subject.render('index', json_types, binding).should match("{text: 'success'}")
+  end
+
+  it 'returns an ArgumentError, if given template does not exist' do
+    expect {
+      subject.render('foobar', html_types, binding)
+    }.to raise_error(ArgumentError, "No template found for 'foobar'!")
+  end
+
+  it 'returns an ArgumentError, if no template fits types' do
+    expect {
+      subject.render('index', foo_types, binding)
+    }.to raise_error(
+      ArgumentError,
+      "No template found for any of this types #{foo_types.join ', '}!"
+    )
+  end
+end

data/spec/unit/renderer/template_path.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Zero::Renderer, '#template_path' do
+  subject { Zero::Renderer.new(template_path) }
+  let(:template_path) { 'foo' }
+
+  its(:type_map) { should be(template_path) }
+end

data/spec/unit/renderer/type_map_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Zero::Renderer, '#type_map' do
+  subject { Zero::Renderer.new(template_path, type_map) }
+  let(:template_path) { 'foo' }
+  let(:type_map) { {'html' => ['text/html']} }
+
+  its(:type_map) { should be(type_map) }
+end

data/spec/unit/request/accept/encoding_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Zero::Request::Accept, '#encoding' do
+  subject { Zero::Request::Accept.new(env) }
+  let(:encoding) { 'en_US' }
+  let(:env) { EnvGenerator.get('/foo', {'HTTP_ACCEPT_ENCODING' => encoding}) }
+
+  its(:encoding) { should be_an_instance_of(Zero::Request::AcceptType) }
+end

data/spec/unit/request/accept/language_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Zero::Request::Accept, '#language' do
+  subject { Zero::Request::Accept.new(env) }
+  let(:language) { 'en_US' }
+  let(:env) { EnvGenerator.get('/foo', {'HTTP_ACCEPT_LANGUAGE' => language}) }
+
+  its(:language) { should be_an_instance_of(Zero::Request::AcceptType) }
+end

data/spec/unit/request/accept/types_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Zero::Request::Accept, '#types' do
+  subject { Zero::Request::Accept.new(env) }
+  let(:media_types) { 'text/html' }
+  let(:env) { EnvGenerator.get('/foo', {'HTTP_ACCEPT' => media_types}) }
+
+  its(:types) { should be_an_instance_of(Zero::Request::AcceptType) }
+end

data/spec/unit/request/accept_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Zero::Request, '#accept' do
+  subject { Zero::Request.new(env) }
+  let(:env) { EnvGenerator.get('/foo') }
+  its(:accept) { should be_an_instance_of(Zero::Request::Accept) }
+end

data/spec/unit/request/accepttype/each_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Zero::Request::AcceptType, '#each' do
+  subject { Zero::Request::AcceptType.new(types) }
+  let(:html) { 'text/html' }
+  let(:json) { 'application/json' }
+  let(:types) { [html, json].join(',') }
+
+  specify { expect {|b| subject.each(&b) }.to yield_successive_args(html, json) }
+end

data/spec/unit/request/accepttype/preferred_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Zero::Request::AcceptType, '#preferred' do
+  subject { Zero::Request::AcceptType }
+  let(:html) { 'text/html' }
+  let(:json) { 'application/json' }
+  let(:foo)  { 'text/foo' }
+  let(:lower_quality) { foo + ';q=0.5' }
+  let(:default) { '*/*;q=0.1' }
+  let(:simple_accept)  { [html, json].join(',') }
+  let(:quality_accept) { [html, lower_quality, default].join(',') }
+  let(:random_accept)  { [lower_quality, default, html].join(',') }
+  let(:lower_accept)   { [lower_quality, default].join(',') }
+  
+  context 'without mapping' do
+    it { subject.new(html).preferred.should           == html }
+    it { subject.new(json).preferred.should           == json }
+    it { subject.new(simple_accept).preferred.should  == html }
+    it { subject.new(quality_accept).preferred.should == html }
+    it { subject.new(random_accept).preferred.should  == html }
+    it { subject.new(lower_accept).preferred.should   == foo }
+  end
+
+#  context 'with mapping' do
+#    before :all do
+#      Zero::Request::Accept.map = {'text/html' => 'html'}
+#    end
+#
+#    after :all do
+#      Zero::Request::Accept.map = {}
+#    end
+#
+#    it { subject.new(html).preferred.should == 'html' }
+#  end
+end

data/spec/unit/request/client/address_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Zero::Request::Client, '#address' do
+  subject { Zero::Request::Client.new(env) }
+  let(:address) { '127.0.0.1' }
+  let(:env) { {'REMOTE_ADDR' => address} }
+
+  its(:address) { should == address }
+end

data/spec/unit/request/client/hostname_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Zero::Request::Client, '#hostname' do
+  subject { Zero::Request::Client.new(env) }
+  let(:hostname) { 'foo.bar' }
+  let(:env) { {'REMOTE_HOST' => hostname} }
+
+  its(:hostname) { should == hostname }
+end

data/spec/unit/request/client/user_agent_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Zero::Request::Client, '#user_agent' do
+  subject { Zero::Request::Client.new(env) }
+  let(:user_agent) { 'Mozilla (dummy agent)' }
+  let(:env) { {'HTTP_USER_AGENT' => user_agent} }
+
+  its(:user_agent) { should == user_agent }
+end

data/spec/unit/request/client_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Zero::Request, '#client' do
+  subject { Zero::Request.new(env) }
+  let(:env) { EnvGenerator.get('/foo') }
+
+  its(:client) { should be_an_instance_of(Zero::Request::Client) }
+end

data/spec/unit/request/content_type_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Zero::Request, '#content_type' do
+  subject { Zero::Request.new(env) }
+
+  context 'returns nil with no content type' do
+    let(:env) { EnvGenerator.get('/foo') }
+    its('content_type') { should be(nil) }
+  end
+
+  context 'returns the set content type' do
+    let(:content_type) { 'bogus/type' }
+    let(:env) { EnvGenerator.post('/foo', {'CONTENT_TYPE' => content_type}) }
+    its('content_type') { should be(content_type) }
+  end
+end

data/spec/unit/request/create_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Zero::Request, '.create' do
+  subject { Zero::Request.new(env) }
+
+  context "with a fresh environment" do
+    let(:env) { EnvGenerator.get('/foo') }
+    it "creates an instance of Zero::Request" do
+      Zero::Request.create(env).should be_an_instance_of(Zero::Request)
+    end
+  end
+
+  context "with an already used environment" do
+    let(:env) { EnvGenerator.get('/foo') }
+    let(:new_env) { subject.env }
+
+    it "returns an already build request" do
+      Zero::Request.create(new_env).should be(subject)
+    end
+  end
+end

data/spec/unit/request/delete_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Zero::Request, '#delete?' do
+  subject { Zero::Request.new(env) }
+
+  context "with a delete request" do
+    let(:env) { EnvGenerator.delete('/foo') }
+    its(:delete?) { should be(true) }
+  end
+
+  context "with a get request" do
+    let(:env) { EnvGenerator.get('/foo') }
+    its(:delete?) { should be(false) }
+  end
+end

data/spec/unit/request/get_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Zero::Request, '#get?' do
+  subject { Zero::Request.new(env) }
+
+  context "with a get request" do
+    let(:env) { EnvGenerator.get('/foo') }
+    its(:get?) { should be(true) }
+  end
+
+  context "with a post request" do
+    let(:env) { EnvGenerator.post('/foo') }
+    its(:get?) { should be(false) }
+  end
+end

data/spec/unit/request/head_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Zero::Request, '#head?' do
+  subject { Zero::Request.new(env) }
+
+  context "with a head request" do
+    let(:env) { EnvGenerator.head('/foo') }
+    its(:head?) { should be(true) }
+  end
+
+  context "with a get request" do
+    let(:env) { EnvGenerator.get('/foo') }
+    its(:head?) { should be(false) }
+  end
+end

data/spec/unit/request/method_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Zero::Request, '#method' do
+  subject { Zero::Request.new(env) }
+  let(:env) { EnvGenerator.get('/foo') }
+
+  its(:method) { should == :get }
+end

data/spec/unit/request/parameter/[]_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Zero::Request::Parameter, '#[]' do
+  subject { Zero::Request::Parameter.new(env) }
+
+  context 'without parameters' do
+    let(:env) { EnvGenerator.get('/foo') }
+
+    it 'returns the custom parameter' do
+      subject['foo'] = 'bar'
+      expect(subject['foo']).to eq('bar')
+    end
+  end
+
+  context 'with query parameters' do
+    let(:env) { EnvGenerator.get('/foo?foo=bar') }
+
+    it 'returns the query parameter' do
+      expect(subject['foo']).to eq('bar')
+    end
+
+    it 'returns the custom parameter' do
+      subject['foo'] = 'baz'
+      expect(subject['foo']).to eq('baz')
+    end
+  end
+
+  context 'with payload parameters' do
+    let(:env) do
+      EnvGenerator.post('/foo', {
+        :input => 'foo=bar', 'CONTENT_TYPE' => 'multipart/form-data'
+      })
+    end
+
+    it 'returns the payload value' do
+      expect(subject['foo']).to eq('bar')
+    end
+
+    it 'returns the custom parameter' do
+      subject['foo'] = 'baz'
+      expect(subject['foo']).to eq('baz')
+    end
+  end
+
+  context 'with query and payload parameters' do
+    let(:env) do
+      EnvGenerator.post('/foo?foo=baz', {
+        :input => 'foo=bar', 'CONTENT_TYPE' => 'multipart/form-data'
+      })
+    end
+
+    it 'returns the payload parameter' do
+      expect(subject['foo']).to eq('bar')
+    end
+  end
+end