volt 0.8.27.beta6 → 0.8.27.beta7

data/spec/models/persistors/params_spec.rb

@@ -4,14 +4,14 @@ require 'volt/models'
 describe Volt::Persistors::Params do
   it 'should stay as params classes when used' do
     a = Volt::Model.new({}, persistor: Volt::Persistors::Params)
-    expect(a._test.class).to eq(Volt::Model)
+    # expect(a._test!.class).to eq(Volt::Model)
+    #
+    # expect(a._test!._cool!.persistor.class).to eq(Volt::Persistors::Params)
 
-    expect(a._test._cool.persistor.class).to eq(Volt::Persistors::Params)
-
-    a._items << { name: 'Test' }
-
-    expect(a._items.persistor.class).to eq(Volt::Persistors::Params)
-    expect(a._items[0].persistor.class).to eq(Volt::Persistors::Params)
-    expect(a._items[0]._name.class).to eq(String)
+    a._items! << { name: 'Test' }
+    #
+    # expect(a._items.persistor.class).to eq(Volt::Persistors::Params)
+    # expect(a._items[0].persistor.class).to eq(Volt::Persistors::Params)
+    # expect(a._items[0]._name!.class).to eq(String)
   end
 end

data/spec/models/persistors/store_spec.rb

@@ -8,7 +8,7 @@ describe Volt::Persistors::Store do
     expect(persistor_instance).to receive(:loaded)
     expect(persistor).to receive(:new).and_return(persistor_instance)
 
-    @model = Volt::Model.new(nil, persistor: persistor)
+    @model = Volt::Model.new({}, persistor: persistor)
 
     expect(persistor_instance).to receive(:changed)
 

data/spec/models/user_validation_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 describe Volt::UserValidatorHelpers do
   context "with user" do
     before do
-      allow(Volt).to receive(:user_id) { 294 }
+      allow(Volt).to receive(:current_user_id) { 294 }
     end
 
     it 'should assign user_id when owning by a user' do

data/spec/router/routes_spec.rb

@@ -9,41 +9,91 @@ end
 describe Volt::Routes do
   it 'should setup direct routes' do
     routes do
-      get '/', view: 'index'
-      get '/page1', view: 'first_page'
+      client '/', view: 'index'
+      client '/page1', view: 'first_page'
+      get '/page2', controller: 'page', action: 'show'
     end
 
     direct_routes = @routes.instance_variable_get(:@direct_routes)
-    expect(direct_routes).to eq('/' => { view: 'index' }, '/page1' => { view: 'first_page' })
+    expect(direct_routes[:client]).to eq('/' => { view: 'index' }, '/page1' => { view: 'first_page' })
+    expect(direct_routes[:get]).to eq('/page2' => { controller: 'page', action: 'show' })
   end
 
   it 'should setup indirect routes' do
     routes do
-      get '/blog/{{ id }}/edit', view: 'blog/edit'
-      get '/blog/{{ id }}', view: 'blog/show'
+      client '/blog/{{ id }}/edit', view: 'blog/edit'
+      client '/blog/{{ id }}', view: 'blog/show'
+      get '/comments/{{ id }}/edit', controller: 'comments', action: 'edit'
+      get '/comments/{{ id }}', controller: 'comments', action: 'show'
     end
 
     indirect_routes = @routes.instance_variable_get(:@indirect_routes)
-    expect(indirect_routes).to eq(
+    expect(indirect_routes[:client]).to eq(
       'blog' => {
         '*' => {
           'edit' => {
             nil => { view: 'blog/edit', id: 1 }
-          },
-          nil => { view: 'blog/show', id: 1 }
+            },
+            nil => { view: 'blog/show', id: 1 }
+          }
         }
-      }
-    )
+        )
+
+    expect(indirect_routes[:get]).to eq(
+      'comments' => {
+        '*' => {
+          'edit' => {
+            nil => { controller: 'comments', action: 'edit', id: 1 }
+            },
+            nil => { controller: 'comments', action: 'show', id: 1 }
+          }
+        }
+        )      
   end
 
+  it 'should setup param matchers' do
+    routes do
+      client '/blog', view: 'blog'
+      client '/blog/{{ id }}', view: 'blog/show'
+      client '/blog/{{ id }}/edit', view: 'blog/edit'
+      client '/blog/tags/{{ tag }}', view: 'blog/tag'
+      client '/login/{{ name }}/user/{{ id }}', view: 'login', action: 'user'
+      get '/articles', controller: 'articles', action: 'index'
+      get '/articles/{{ id }}', controller: 'articles', action: 'show'
+    end
+
+    param_matches = @routes.instance_variable_get(:@param_matches)
+    expect(param_matches[:client].map { |v| v[0] }).to eq([
+      { view: 'blog' },
+      { view: 'blog/show', id: nil },
+      { view: 'blog/edit', id: nil },
+      { view: 'blog/tag', tag: nil },
+      { view: 'login', action: 'user', name: nil, id: nil }
+      ])
+
+    expect(param_matches[:get].map { |v| v[0] }).to eq([
+      { controller: 'articles', action: 'index' },
+      { controller: 'articles', action: 'show', id: nil },
+      ])    
+  end
+
+
   it 'should match routes' do
     routes do
-      get '/blog', view: 'blog'
-      get '/blog/{{ id }}', view: 'blog/show'
-      get '/blog/{{ id }}/draft', view: 'blog/draft', action: 'draft'
-      get '/blog/{{ id }}/edit', view: 'blog/edit'
-      get '/blog/tags/{{ _tag }}', view: 'blog/tag'
-      get '/login/{{ name }}/user/{{ id }}', view: 'login', action: 'user'
+      client '/blog', view: 'blog'
+      client '/blog/{{ id }}', view: 'blog/show'
+      client '/blog/{{ id }}/draft', view: 'blog/draft', action: 'draft'
+      client '/blog/{{ id }}/edit', view: 'blog/edit'
+      client '/blog/tags/{{ tag }}', view: 'blog/tag'
+      client '/login/{{ name }}/user/{{ id }}', view: 'login', action: 'user'
+      get '/articles', controller: 'articles', action: 'index'
+      get '/articles/{{ id }}', controller: 'articles', action: 'show'
+      put '/articles/{{ articles_id }}/comments/{{ id }}', controller: 'comments', action: 'update'
+      post '/comments', controller: 'comments', action: 'create'
+      put '/people', controller: 'people', action: 'update'
+      patch '/people/1', controller: 'people', action: 'update'
+      delete '/people/2', controller: 'people', action: 'destroy'
+
     end
 
     params = @routes.url_to_params('/blog')
@@ -56,7 +106,7 @@ describe Volt::Routes do
     expect(params).to eq(view: 'blog/show', id: '55')
 
     params = @routes.url_to_params('/blog/tags/good')
-    expect(params).to eq(view: 'blog/tag', _tag: 'good')
+    expect(params).to eq(view: 'blog/tag', tag: 'good')
 
     params = @routes.url_to_params('/blog/55/draft')
     expect(params).to eq(view: 'blog/draft', id: '55', action: 'draft')
@@ -66,34 +116,44 @@ describe Volt::Routes do
 
     params = @routes.url_to_params('/login/cool')
     expect(params).to eq(false)
-  end
 
-  it 'should setup param matchers' do
-    routes do
-      get '/blog', view: 'blog'
-      get '/blog/{{ id }}', view: 'blog/show'
-      get '/blog/{{ id }}/edit', view: 'blog/edit'
-      get '/blog/tags/{{ _tag }}', view: 'blog/tag'
-      get '/login/{{ name }}/user/{{ id }}', view: 'login', action: 'user'
-    end
+    params = @routes.url_to_params(:get, '/articles')
+    expect(params).to eq(controller: 'articles', action: 'index')
 
-    param_matches = @routes.instance_variable_get(:@param_matches)
-    expect(param_matches.map { |v| v[0] }).to eq([
-      { view: 'blog' },
-      { view: 'blog/show', id: nil },
-      { view: 'blog/edit', id: nil },
-      { view: 'blog/tag', _tag: nil },
-      { view: 'login', action: 'user', name: nil, id: nil }
-    ])
+    params = @routes.url_to_params('get', '/articles')
+    expect(params).to eq(controller: 'articles', action: 'index')
+
+    params = @routes.url_to_params(:post, '/articles')
+    expect(params).to be_nil
+
+    params = @routes.url_to_params(:post, '/comments')
+    expect(params).to eq(controller: 'comments', action: 'create')
+
+    params = @routes.url_to_params(:put, '/people')
+    expect(params).to eq(controller: 'people', action: 'update')
+
+    params = @routes.url_to_params(:patch, '/people/1')
+    expect(params).to eq(controller: 'people', action: 'update')
+
+    params = @routes.url_to_params(:delete, '/people/2')
+    expect(params).to eq(controller: 'people', action: 'destroy') 
+
+    params = @routes.url_to_params(:get, '/articles/2')
+    expect(params).to eq(controller: 'articles', action: 'show', id: '2')
+
+    params = @routes.url_to_params(:put, '/articles/2/comments/9')
+    expect(params).to eq(controller: 'comments', action: 'update', articles_id: '2', id: '9') 
   end
 
   it 'should go from params to url' do
     routes do
-      get '/blog', view: 'blog'
-      get '/blog/{{ id }}', view: 'blog/show'
-      get '/blog/{{ id }}/edit', view: 'blog/edit'
-      get '/blog/tags/{{ _tag }}', view: 'blog/tag'
-      get '/login/{{ name }}/user/{{ id }}', view: 'login', action: 'user'
+      client '/blog', view: 'blog'
+      client '/blog/{{ id }}', view: 'blog/show'
+      client '/blog/{{ id }}/edit', view: 'blog/edit'
+      client '/blog/tags/{{ tag }}', view: 'blog/tag'
+      client '/login/{{ name }}/user/{{ id }}', view: 'login', action: 'user'
+      get '/articles/{{ id }}', controller: 'articles', action: 'show'
+      put '/articles/{{ id }}', controller: 'articles', action: 'update'
     end
 
     url, params = @routes.params_to_url(view: 'blog/show', id: '55')
@@ -107,6 +167,14 @@ describe Volt::Routes do
     url, params = @routes.params_to_url(view: 'blog/edit', id: '100', other: 'should_pass')
     expect(url).to eq('/blog/100/edit')
     expect(params).to eq(other: 'should_pass')
+
+    url, params = @routes.params_to_url(controller: 'articles', action: 'show', method: :get, id: 10)
+    expect(url).to eq('/articles/10')
+    expect(params).to eq({})
+
+    url, params = @routes.params_to_url(controller: 'articles', action: 'update', method: :put, id: 99, other: 'xyz')
+    expect(url).to eq('/articles/99')
+    expect(params).to eq({other: 'xyz'})    
   end
 
   it 'should test that params match a param matcher' do
@@ -142,8 +210,8 @@ describe Volt::Routes do
     params._index = '5'
 
     routes do
-      get '/', controller: 'index'
-      get '/blog', controller: 'blog'
+      client '/', controller: 'index'
+      client '/blog', controller: 'blog'
     end
 
     path, cleaned_params = @routes.params_to_url(params.to_h)
@@ -155,8 +223,8 @@ describe Volt::Routes do
     params = Volt::Model.new({}, persistor: Volt::Persistors::Params)
 
     routes do
-      get '/', controller: 'index'
-      get '/blog/{{ id }}', controller: 'blog'
+      client '/', controller: 'index'
+      client '/blog/{{ id }}', controller: 'blog'
     end
 
     params = @routes.url_to_params('/blog/20')

data/spec/server/rack/http_request_spec.rb

@@ -0,0 +1,50 @@
+if RUBY_PLATFORM != 'opal'
+  require 'volt/server/rack/http_request'
+
+  describe Volt::HttpRequest do
+    def env_for(url, opts = {})
+      Rack::MockRequest.env_for(url, opts)
+    end
+
+    it 'should report the correct format' do
+      env = env_for('http://example.com/test.html',
+                    'CONTENT_TYPE' => 'text/plain;charset=utf-8')
+      request = Volt::HttpRequest.new(env)
+      expect(request.format).to eq('html')
+
+      env = env_for('http://example.com/test',
+                    'CONTENT_TYPE' => 'text/plain;charset=utf-8')
+      request = Volt::HttpRequest.new(env)
+      expect(request.format).to eq('text/plain')
+    end
+
+    it 'should remove the format from the path' do
+      env = env_for('http://example.com/test.html',
+                    'CONTENT_TYPE' => 'text/plain;charset=utf-8')
+      request = Volt::HttpRequest.new(env)
+      expect(request.path).to eq('/test')
+    end
+
+    it 'should return the correct http method' do
+      env = env_for('http://example.com/test.html', method: 'GET')
+      request = Volt::HttpRequest.new(env)
+      expect(request.method).to eq(:get)
+
+      env = env_for('http://example.com/test.html',
+                    method: 'POST', params: { _method: 'put' })
+      request = Volt::HttpRequest.new(env)
+      expect(request.method).to eq(:put)
+    end
+
+    it 'should return the params with symbolized keys' do
+      env = env_for(
+        'http://example.com/test.html',
+        method: 'POST',
+        params: { 'some' => 'params', 'as' => 'strings', and: 'symbols' })
+      request = Volt::HttpRequest.new(env)
+
+      wanted = { some: 'params', as: 'strings', and: 'symbols' }
+      expect(request.params).to eq(wanted)
+    end
+  end
+end

data/spec/server/rack/http_resource_spec.rb

@@ -0,0 +1,59 @@
+if RUBY_PLATFORM != 'opal'
+  require 'volt/server/rack/http_resource'
+  require 'volt/controllers/http_controller'
+  require 'volt/server/rack/http_request'
+  require 'volt/router/routes'
+
+  describe Volt::HttpResource do
+    def routes(&block)
+      @routes = Volt::Routes.new
+      @routes.define(&block)
+    end
+
+    class SimpleController < Volt::HttpController
+      attr_reader :action_called
+
+      def index
+        @action_called = true
+        render text: 'just some text'
+      end
+
+      def show
+        render text: "show with id #{params[:stuff_id]} " \
+                      "and #{params[:test]} called"
+      end
+    end
+
+    let(:app) { ->(env) { [404, env, 'app'] } }
+
+    before(:each) do
+      routes do
+        get '/stuff', controller: 'simple', action: 'index'
+        get '/stuff/{{ stuff_id }}', controller: 'simple', action: 'show'
+      end
+    end
+
+    it 'should initialize the correct controller and call the correct action' do
+      http_resource = Volt::HttpResource.new(app, @routes)
+      env = Rack::MockRequest.env_for('http://example.com/stuff')
+      request = Volt::HttpRequest.new(env)
+      controller = SimpleController.new({}, request)
+      expect(SimpleController).to receive(:new).and_return(controller)
+
+      response = http_resource.call(env)
+      expect(response.status).to eq(200)
+      expect(response.body).to eq(['just some text'])
+      expect(controller.action_called).to eq(true)
+    end
+
+    it 'should parse the correct params to the controller' do
+      http_resource = Volt::HttpResource.new(app, @routes)
+      env = Rack::MockRequest.env_for('http://example.com/stuff/99?test=another_param')
+      request = Volt::HttpRequest.new(env)
+
+      response = http_resource.call(env)
+      expect(response.status).to eq(200)
+      expect(response.body).to eq(['show with id 99 and another_param called'])
+    end
+  end
+end

data/spec/server/rack/http_response_header_spec.rb

@@ -0,0 +1,34 @@
+require 'volt/server/rack/http_response_header'
+
+describe Volt::HttpResponseHeader do
+  it 'it should headerize the keys' do
+    header = Volt::HttpResponseHeader.new
+    header[:content_type] = 'test'
+    expect(header['Content-Type']).to eq('test')
+    expect(header['content-type']).to eq('test')
+    expect(header['content_type']).to eq('test')
+    expect(header[:content_type]).to eq('test')
+    expect(header.keys).to eq(['Content-Type'])
+  end
+
+  it 'should delete keys' do
+    header = Volt::HttpResponseHeader.new
+    header[:content_type] = 'test'
+    expect(header.delete(:content_type)).to eq('test')
+    expect(header.size).to eq 0
+  end
+
+  it 'should merge other plain hashes and headerize their keys' do
+    header = Volt::HttpResponseHeader.new
+    header[:content_type] = 'test'
+
+    hash = {}
+    hash[:transfer_encoding] = 'encoding'
+
+    expect(header.merge(hash)).to be_a(Volt::HttpResponseHeader)
+    expect(header.merge(hash)['Transfer-Encoding']).to eq('encoding')
+
+    header.merge!(hash)
+    expect(header['Transfer-Encoding']).to eq('encoding')
+  end
+end

data/spec/server/rack/http_response_renderer_spec.rb

@@ -0,0 +1,33 @@
+require 'volt/server/rack/http_response_renderer'
+
+describe Volt::HttpResponseRenderer do
+  let(:renderer) { Volt::HttpResponseRenderer.new }
+
+  it 'should render json' do
+    hash = { a: 'aa', bb: 'bbb' }
+    body, additional_headers = renderer.render json: hash
+    expect(body).to eq(hash.to_json)
+    expect(additional_headers[:content_type]).to eq('application/json')
+  end
+
+  it 'should render plain text' do
+    text = 'just some text'
+    body, additional_headers = renderer.render(text: text)
+    expect(body).to eq(text)
+    expect(additional_headers[:content_type]).to eq('text/plain')
+  end
+
+  it 'should default to text/plain if no suitable renderer could be found' do
+    body, additional_headers = renderer.render(some: 'text')
+    expect(body).to eq('')
+    expect(additional_headers[:content_type]).to eq('text/plain')
+  end
+
+  it 'should add all remaining keys as additional_headers' do
+    text = 'just some text'
+    body, additional_headers = renderer.render(text: text,
+                                               additional: 'headers')
+    expect(body).to eq(text)
+    expect(additional_headers[:additional]).to eq('headers')
+  end
+end

data/spec/tasks/dispatcher_spec.rb

@@ -1,5 +1,5 @@
 if RUBY_PLATFORM != 'opal'
-  class TestTask < Volt::TaskHandler
+  class TestTask < Volt::Task
     def allowed_method(arg1, arg2)
       return 'yes' + arg1 + arg2
     end
@@ -10,7 +10,7 @@ if RUBY_PLATFORM != 'opal'
       Volt.logger = spy('Volt::VoltLogger')
     end
 
-    it 'should only allow method calls on TaskHandler or above in the inheritance chain' do
+    it 'should only allow method calls on Task or above in the inheritance chain' do
       channel = double('channel')
 
       expect(channel).to receive(:send_message).with('response', 0, 'yes it works', nil)