rocketio 0.1.0 → 0.2.0

data/test/filters_test.rb

@@ -6,172 +6,189 @@ spec :Filters do
     it 'inherits filters from superclass' do
       before, around, after = [], [], []
       a = mock_controller {
-        before(:get) {before << :a}
-        around(:get) {|a| around << :a}
-        after(:get)  {after  << :a}
-        def get; end
+        before(:a) {before << :a}
+        around(:a) {|a| around << :a}
+        after(:a)  {after  << :a}
+      }
+      b = mock_controller(a) {
+        def a; end
       }
-      b = mock_controller(a)
       app(b)
-      get
+      get :a
       assert([before, around, after]).all? {|a| a.include?(:a)}
     end
 
     it 'inherits filters explicitly' do
       before, around, after = [], [], []
       a = mock_controller {
-        before(:get) {before << :x}
-        around(:get) {|a| around << :x}
-        after(:get)  {after  << :x}
-        def get; end
+        before(:a) {before << :x}
+        around(:a) {|a| around << :x}
+        after(:a)  {after  << :x}
       }
       b = mock_controller {
         import :before, from: a
         import :around, from: a
         import :after, from: a
+        def a; end
       }
       app(b)
-      get
+      get :a
       assert([before, around, after]).all? {|a| a.include?(:x)}
     end
 
     test 'explicitly inherited filters overrides filters inherited from superclass' do
       before, around, after = [], [], []
       a = mock_controller {
-        before(:get) {before << :a}
-        around(:get) {|a| around << :a}
-        after(:get)  {after  << :a}
-        def get; end
+        before(:a) {before << :a}
+        around(:a) {|a| around << :a}
+        after(:a)  {after  << :a}
       }
       b = mock_controller {
-        before(:get) {before << :b}
-        around(:get) {|a| around << :b}
-        after(:get)  {after  << :b}
+        before(:a) {before << :b}
+        around(:a) {|a| around << :b}
+        after(:a)  {after  << :b}
       }
       c = mock_controller(a) {
         import :before, from: b
         import :around, from: b
         import :after, from: b
+        def a; end
       }
       app(c)
-      get
+      get :a
       assert([before, around, after]).none? {|a| a.include?(:a)}
       assert([before, around, after]).all? {|a| a.include?(:b)}
     end
 
     test 'explicitly inherited filters complements filters inherited from superclass' do
-      before_get, around_get, after_get = [], [], []
-      before_post, around_post, after_post = [], [], []
+      before_a, around_a, after_a = [], [], []
+      before_b, around_b, after_b = [], [], []
       a = mock_controller {
-        before(:get) {before_get << :a}
-        around(:get) {|a| around_get << :a}
-        after(:get)  {after_get  << :a}
+        before(:a) {before_a << :a}
+        around(:a) {|a| around_a << :a}
+        after(:a)  {after_a  << :a}
       }
       b = mock_controller {
-        before(:post) {before_post << :b}
-        around(:post) {|a| around_post << :b}
-        after(:post)  {after_post  << :b}
+        before(:b) {before_b << :b}
+        around(:b) {|a| around_b << :b}
+        after(:b)  {after_b  << :b}
       }
       c = mock_controller(a) {
         import :before, from: b
         import :around, from: b
         import :after, from: b
+        def a; end
+        def b; end
       }
       app(c)
-      get
-      assert([before_get, around_get, after_get]).all? {|a| a.include?(:a)}
-      post
-      assert([before_post, around_post, after_post]).all? {|a| a.include?(:b)}
+      get :a
+      assert([before_a, around_a, after_a]).all? {|a| a.include?(:a)}
+      get :b
+      assert([before_b, around_b, after_b]).all? {|a| a.include?(:b)}
     end
 
-    it 'defined filters overrides filters inherited from superclass' do
+    test 'defined filters overrides filters inherited from superclass' do
       before, around, after = [], [], []
       a = mock_controller {
-        before(:get) {before << :a}
-        around(:get) {|a| around << :a}
-        after(:get)  {after  << :a}
+        before(:a) {before << :a}
+        around(:a) {|a| around << :a}
+        after(:a)  {after  << :a}
       }
       b = mock_controller(a) {
-        before(:get) {before << :b}
-        after(:get)  {after  << :b}
+        before(:a) {before << :b}
+        after(:a)  {after  << :b}
+        def a; end
       }
       app(b)
-      get
+      get :a
       assert([before, after]).all? {|a| a == [:b]}
       assert(around) == [:a]
     end
   end
 
-  it 'defines filters for all requested methods if called without arguments' do
+  it 'defines filters for all methods if called without arguments' do
     before, around, after = [], [], []
     app mock_controller {
-      before() {before << requested_method}
-      around() {|a| around << requested_method}
-      after()  {after  << requested_method}
+      before {before << requested_method}
+      around {|a| around << requested_method}
+      after  {after  << requested_method}
+      def a; end
+      def b; end
+      def c; end
     }
     filters = [before, around, after]
 
-    get
-    assert(filters).all? {|a| a.include?(:get)}
-
-    post
-    assert(filters).all? {|a| a.include?(:post)}
-
-    put
-    assert(filters).all? {|a| a.include?(:put)}
+    get :a
+    assert(filters).all? {|a| a.include?(:a)}
 
-    head
-    assert(filters).all? {|a| a.include?(:head)}
+    get :b
+    assert(filters).all? {|a| a.include?(:b)}
 
-    delete
-    assert(filters).all? {|a| a.include?(:delete)}
+    get :c
+    assert(filters).all? {|a| a.include?(:c)}
   end
 
   it 'defines filters only for given requested method(s)' do
     before, around, after = [], [], []
     app mock_controller {
-      before(:get) {before << requested_method}
-      around(:put, :post) {|a| around << requested_method}
-      after(:delete) {after << requested_method}
-      def delete; end
+      before(:a) {before << requested_method}
+      around(:b, :c) {|a| around << requested_method}
+      after(:d) {after << requested_method}
+      def a; end
+      def b; end
+      def c; end
+      def d; end
     }
-    get
-    assert(before).include?(:get)
-    assert([around, after]).none? {|a| a.include?(:get)}
 
-    post
-    assert(around).include?(:post)
-    assert([before, after]).none? {|a| a.include?(:post)}
+    get :a
+    assert(before).include?(:a)
+    assert([around, after]).none? {|a| a.include?(:a)}
 
-    put
-    assert(around).include?(:put)
-    assert([before, after]).none? {|a| a.include?(:put)}
+    get :b
+    assert(around).include?(:b)
+    assert([before, after]).none? {|a| a.include?(:b)}
 
-    delete
-    assert(after).include?(:delete)
-    assert([before, around]).none? {|a| a.include?(:delete)}
+    get :c
+    assert(around).include?(:c)
+    assert([before, after]).none? {|a| a.include?(:c)}
+
+    get :d
+    assert(after).include?(:d)
+    assert([before, around]).none? {|a| a.include?(:d)}
   end
 
-  it 'creates a void filter if called without a block' do
+  it 'creates a void wildcard filter if called without a block' do
     ctrl = mock_controller {
-      before(:get) {raise 'this should be overridden'}
-      before(:get)
-      def get; end
-    }.initialize_controller
+      before {raise 'this should be overridden'}
+      before
+      def index; end
+    }.new
     app(ctrl)
-    expect(ctrl).to_receive(:__before_get__)
+    expect(ctrl).to_receive(:'__before_*__')
     get
   end
 
+  it 'creates a void named filter if called without a block' do
+    ctrl = mock_controller {
+      before(:index) {raise 'this should be overridden'}
+      before(:index)
+      def index; end
+    }.new
+    app(ctrl)
+    expect(ctrl).to_receive(:__before_index__)
+    get :index
+  end
+
   it 'it calls wildcard filters before specialized ones' do
     buffer = []
     app mock_controller {
       # specialized filter, called only on GET requests
-      before(:get) {buffer << requested_method}
+      before(:a) {buffer << requested_method}
       # wildcard filter, called on any requests
       before {buffer << :*}
+      def a; end
     }
-    get
-    assert(buffer) == [:*, :get]
+    get :a
+    assert(buffer) == [:*, :a]
   end
 end

data/test/halt_test.rb

@@ -3,7 +3,7 @@ require 'setup'
 spec :HaltTest do
   def halt_app *args, &block
     app mock_controller {
-      define_method(:get) {
+      define_method(:index) {
         instance_exec(&block) if block
         halt(*args)
       }

data/test/helpers_test.rb

@@ -6,7 +6,7 @@ spec :HelpersTest do
     code += 2 if [204, 205, 304].include? code
     block ||= proc { }
     app mock_controller {
-      define_method :get do
+      define_method :index do
         response.status = code
         instance_eval(&block).inspect
       end
@@ -116,7 +116,7 @@ spec :HelpersTest do
   context 'body' do
     it 'takes a block for deferred body generation' do
       app mock_controller {
-        define_method(:get) { response.body = -> { 'Hello World' } }
+        define_method(:index) { response.body = -> { 'Hello World' } }
       }
 
       get
@@ -125,7 +125,7 @@ spec :HelpersTest do
 
     it 'takes a String, Array, or other object responding to #each' do
       app mock_controller {
-        define_method(:get) { response.body = 'Hello World' }
+        define_method(:index) { response.body = 'Hello World' }
       }
 
       get
@@ -136,7 +136,7 @@ spec :HelpersTest do
   context 'headers' do
     it 'sets headers on the response object when given a Hash' do
       app mock_controller {
-        define_method(:get) {headers 'X-Foo' => 'bar', 'X-Baz' => 'bling'}
+        define_method(:index) {headers 'X-Foo' => 'bar', 'X-Baz' => 'bling'}
       }
 
       get
@@ -147,7 +147,7 @@ spec :HelpersTest do
 
     it 'returns the response headers hash when no hash provided' do
       app mock_controller {
-        define_method(:get) {headers['X-Foo'] = 'bar'}
+        define_method(:index) {headers['X-Foo'] = 'bar'}
       }
 
       get
@@ -159,7 +159,7 @@ spec :HelpersTest do
   context 'back' do
     it "makes redirecting back pretty" do
       app mock_controller('/foo') {
-        def get; redirect back end
+        def index; redirect back end
       }
 
       env['HTTP_REFERER'] = 'http://github.com'

data/test/middleware_test.rb

@@ -15,7 +15,7 @@ spec :Middleware do
       use(ware) {buff << :y}
     }
     b = mock_controller(a) {
-      def get; end
+      def index; end
     }
     app mock_app(b)
     get
@@ -30,7 +30,7 @@ spec :Middleware do
     b = mock_controller {
       use(ware) { buff << 3 }
       import :middleware, from: a
-      def get; end
+      def index; end
     }
     app mock_app(b)
     get
@@ -44,11 +44,11 @@ spec :Middleware do
     }
     b = mock_controller(a) {
       use(ware) {buff << :z}
-      def get; end
+      def index; end
     }
     c = mock_controller(a) {
       import :middleware, from: b
-      def get; end
+      def index; end
     }
     app mock_app(c)
     get

data/test/redirect_test.rb

@@ -28,8 +28,7 @@ require 'setup'
 spec :Redirect do
   before do
     app mock_controller {
-      define_method(:get) { redirect '/foo' }
-      define_method(:post) { redirect '/foo' }
+      define_method(:index) { redirect '/foo' }
     }
     env.clear
   end
@@ -43,7 +42,7 @@ spec :Redirect do
 
   it 'uses 301 for permanent redirects' do
     app mock_controller {
-      define_method(:get) { permanent_redirect '/foo' }
+      define_method(:index) { permanent_redirect '/foo' }
     }
 
     get
@@ -54,7 +53,7 @@ spec :Redirect do
 
   it 'redirects back to request.referer when passed back' do
     app mock_controller(:try_redirect) {
-      define_method(:get) { redirect back }
+      define_method(:index) { redirect back }
     }
 
     env['HTTP_REFERER'] = '/foo'
@@ -102,7 +101,7 @@ spec :Redirect do
 
   it 'accepts absolute URIs' do
     app mock_controller {
-      define_method(:get) {redirect 'http://google.com'}
+      define_method(:index) {redirect 'http://google.com'}
     }
 
     get
@@ -113,7 +112,7 @@ spec :Redirect do
 
   it 'accepts absolute URIs with a different schema' do
     app mock_controller {
-      define_method(:get) {redirect 'mailto:jsmith@example.com'}
+      define_method(:index) {redirect 'mailto:jsmith@example.com'}
     }
 
     get
@@ -124,7 +123,7 @@ spec :Redirect do
 
   it 'accepts a URI object instead of a String' do
     app mock_controller {
-      define_method(:get) {redirect URI.parse('http://sinatrarb.com')}
+      define_method(:index) {redirect URI.parse('http://sinatrarb.com')}
     }
 
     get

data/test/render/engine_test.rb

@@ -7,7 +7,7 @@ spec :engine do
     }
     b = mock_controller(a) {
     }
-    assert(b.initialize_controller.engine) == [:SlimTemplate, []]
+    assert(b.new.engine) == [:SlimTemplate, []]
   end
 
   it 'overrides engine inherited from superclass' do
@@ -17,7 +17,7 @@ spec :engine do
     b = mock_controller(a) {
       engine :Turbo
     }
-    assert(b.initialize_controller.engine) == [:TurboTemplate, []]
+    assert(b.new.engine) == [:TurboTemplate, []]
   end
 
   it 'can use include to override engine inherited from superclass' do
@@ -30,13 +30,13 @@ spec :engine do
     c = mock_controller(a) {
       import :engine, from: b
     }
-    assert(c.initialize_controller.engine) == [:TurboTemplate, []]
+    assert(c.new.engine) == [:TurboTemplate, []]
   end
 
   it 'uses a block (that runs at instance level) to define engine' do
     app mock_controller {
       engine {@x = 'x'; :Slim}
-      def get; engine[0].to_s + @x end
+      def index; engine[0].to_s + @x end
     }
     get
     assert(last_response.body) == 'SlimTemplatex'
@@ -59,7 +59,7 @@ spec :engine do
       engine {
         :ERB if env['IAMABOT']
       }
-      def get; engine[0].to_s end
+      def index; engine[0].to_s end
     }
     app b
     get