rocketio 0.1.0 → 0.2.0

data/test/api_test.rb

@@ -2,7 +2,7 @@ require 'setup'
 
 spec :api do
 
-  it 'should contain only public non-inherited methods' do
+  it 'should not contain methods defined by setup DSL' do
     c = mock_controller {
       basic_auth  {}
       digest_auth {}
@@ -24,12 +24,34 @@ spec :api do
     assert(c.api).empty?
   end
 
+  it 'should contain public methods' do
+    c = mock_controller {
+      def x; end
+    }
+    assert(c.api.keys) == [:x]
+  end
+
+  it 'should exclude protected methods' do
+    c = mock_controller {
+      protected
+      def x; end
+    }
+    assert(c.api).empty?
+  end
+
+  it 'should exclude private methods' do
+    c = mock_controller {
+      private
+      def x; end
+    }
+    assert(c.api).empty?
+  end
 
   it 'should inherit api methods' do
     a = mock_controller {
       def x; end
     }
-    
+
     b = mock_controller(a) {
       def y; end
     }
@@ -37,119 +59,4 @@ spec :api do
     assert(b.api).include?(:x)
     assert(b.api).include?(:y)
   end
-
-
-  context :private_api do
-
-    it 'should contain auth methods' do
-      c = mock_controller {
-        basic_auth  {}
-        digest_auth {}
-        token_auth  {}
-      }
-      assert(c.private_api).include?(:basic_auth)
-      assert(c.private_api).include?(:__basic_auth__get__)
-
-      assert(c.private_api).include?(:digest_auth)
-      assert(c.private_api).include?(:__digest_auth__get__)
-
-      assert(c.private_api).include?(:token_auth)
-    end
-
-    it 'should contain error handler methods' do
-      c = mock_controller {
-        error(500) {}
-      }
-      assert(c.private_api).include?(:error_handlers)
-      assert(c.private_api).include?(:__404_error_handler__)
-      assert(c.private_api).include?(:__409_error_handler__)
-      assert(c.private_api).include?(:__501_error_handler__)
-    end
-
-    it 'should contain filters methods' do
-      c = mock_controller {
-        before {}
-        around {}
-        after  {}
-      }
-      assert(c.private_api).include?(:before)
-      assert(c.private_api).include?(:'__before_*__')
-
-      assert(c.private_api).include?(:around)
-      assert(c.private_api).include?(:'__around_*__')
-
-      assert(c.private_api).include?(:after)
-      assert(c.private_api).include?(:'__after_*__')
-
-    end
-
-    it 'should contain middleware methods' do
-      c = mock_controller {
-        use proc {}
-      }
-      assert(c.private_api).include?(:middleware)
-    end
-
-    it 'should contain session methods' do
-      c = mock_controller {
-        sessions :cookies
-      }
-      assert(c.private_api).include?(:sessions)
-    end
-
-    context :render do
-
-      it 'should contain engine methods' do
-        c = mock_controller {
-          engine :ERB
-        }
-
-        assert(c.private_api).include?(:engine)
-      end
-
-      it 'should contain engine methods when engine defined as block' do
-        c = mock_controller {
-          engine {:ERB}
-        }
-
-        assert(c.private_api).include?(:engine)
-        assert(c.private_api).include?(:__rocketio_engine__)
-      end
-
-      it 'should contain layout methods' do
-        c = mock_controller {
-          layout :main
-          define_layout(:main) {}
-          define_layout(:file, file: :file)
-        }
-
-        assert(c.private_api).include?(:layout)
-        assert(c.private_api).include?(:layouts)
-        assert(c.private_api).include?(:__file_layout_file__)
-        assert(c.private_api).include?(:__file_layout__)
-      end
-
-      it 'should contain template methods' do
-        c = mock_controller {
-          define_template(:main) {}
-          define_template(:file, file: :file)
-        }
-
-        assert(c.private_api).include?(:templates)
-        assert(c.private_api).include?(:__file_template_file__)
-        assert(c.private_api).include?(:__file_template__)
-      end
-
-      it 'should contain template_var methods' do
-        c = mock_controller {
-          define_template_var(:var) {}
-        }
-
-        assert(c.private_api).include?(:__template_vars__)
-        assert(c.private_api).include?(:__var_template_var__)
-      end
-
-    end
-
-  end
 end

data/test/authentication_test.rb

@@ -2,11 +2,14 @@ require 'setup'
 
 spec :AuthenticationTest do
   context 'inheritance' do
+
     it 'inherits basic auth procedures from superclass' do
       a = mock_controller {
         basic_auth {|u,p| [u,p] == %w[u p]}
       }
-      b = mock_controller(a)
+      b = mock_controller(a){
+        def index; end
+      }
       app(b)
       get
       assert(last_response).is_unauthorized
@@ -21,6 +24,7 @@ spec :AuthenticationTest do
       }
       b = mock_controller(a) {
         basic_auth {|u,p| [u,p] == %w[x y]}
+        def index; end
       }
       app(b)
       get
@@ -30,7 +34,7 @@ spec :AuthenticationTest do
       assert(last_response).is_authorized
     end
 
-    it 'uses `inherit` to override basic auth inherited from superclass' do
+    it 'uses `import` to override basic auth inherited from superclass' do
       a = mock_controller {
         basic_auth {|u,p| [u,p] == %w[u p]}
       }
@@ -39,6 +43,7 @@ spec :AuthenticationTest do
       }
       c = mock_controller(a) {
         import :basic_auth, from: b
+        def index; end
       }
       app(c)
       get
@@ -48,12 +53,13 @@ spec :AuthenticationTest do
       assert(last_response).is_authorized
     end
 
-    it 'inherits basic auth procedures' do
+    it 'imports basic auth procedures' do
       a = mock_controller {
         basic_auth {|u,p| [u,p] == %w[u p]}
       }
       b = mock_controller {
         import :basic_auth, from: a
+        def index; end
       }
       app(b)
       get
@@ -67,7 +73,9 @@ spec :AuthenticationTest do
       a = mock_controller {
         digest_auth {|u| {'u' => 'p'}[u]}
       }
-      b = mock_controller(a)
+      b = mock_controller(a) {
+        def index; end
+      }
       app(b)
       get
       assert(last_response).is_unauthorized
@@ -82,6 +90,7 @@ spec :AuthenticationTest do
       }
       b = mock_controller(a) {
         digest_auth {|u| {'x' => 'y'}[u]}
+        def index; end
       }
       app(b)
       get
@@ -91,7 +100,7 @@ spec :AuthenticationTest do
       assert(last_response).is_authorized
     end
 
-    it 'uses `inherit` to override digest auth inherited from superclass' do
+    it 'uses `import` to override digest auth inherited from superclass' do
       a = mock_controller {
         digest_auth {|u| {'u' => 'p'}[u]}
       }
@@ -100,8 +109,9 @@ spec :AuthenticationTest do
       }
       c = mock_controller(a) {
         import :digest_auth, from: b
+        def index; end
       }
-      app(b)
+      app(c)
       get
       assert(last_response).is_unauthorized
       digest_authorize 'x', 'y'
@@ -109,12 +119,13 @@ spec :AuthenticationTest do
       assert(last_response).is_authorized
     end
 
-    it 'inherits digest auth procedures' do
+    it 'imports digest auth procedures' do
       a = mock_controller {
         digest_auth {|u| {'u' => 'p'}[u]}
       }
       b = mock_controller {
         import :digest_auth, from: a
+        def index; end
       }
       app(b)
       get
@@ -126,17 +137,22 @@ spec :AuthenticationTest do
   end
 
   context 'basic auth' do
-    context 'protect all request methods' do
+    context 'protect all methods on any request method' do
+
       before do
         app mock_controller {
           basic_auth {|u,p| [u,p] == %w[u p]}
-          RocketIO::REQUEST_METHODS.each_value {|m| define_method(m) {}}
+          def x; end
+          def y; end
+          def z; end
         }
       end
 
       it 'returns "401 Unauthorized" if no authorization given' do
         RocketIO::REQUEST_METHODS.each_value do |rqm|
-          send(rqm)
+          send(rqm, :x)
+          send(rqm, :y)
+          send(rqm, :z)
           assert(last_response).is_unauthorized
         end
       end
@@ -144,7 +160,9 @@ spec :AuthenticationTest do
       it 'returns "401 Unauthorized" if wrong authorization given' do
         authorize('x', 'y')
         RocketIO::REQUEST_METHODS.values.each do |rqm|
-          send(rqm)
+          send(rqm, :x)
+          send(rqm, :y)
+          send(rqm, :z)
           assert(last_response).is_unauthorized
         end
       end
@@ -152,65 +170,75 @@ spec :AuthenticationTest do
       it 'returns "200 Ok" response if authorization passed' do
         authorize('u', 'p')
         RocketIO::REQUEST_METHODS.values.each do |rqm|
-          send(rqm)
+          send(rqm, :x)
+          send(rqm, :y)
+          send(rqm, :z)
           assert(last_response).ok?
         end
       end
     end
 
-    context 'protect specific request methods' do
+    context 'protect specific methods on any request method' do
       before do
-        @protected = %w[get post]
+        @protected = %w[x y]
         app mock_controller {
-          basic_auth(:get)  {|u,p| [u,p] == ['u', 'get'] }
-          basic_auth(:post) {|u,p| [u,p] == ['u', 'post']}
-          define_method(:get) {}
-          define_method(:post) {}
-          define_method(:put) {}
-          define_method(:delete) {}
+          basic_auth(:x)  {|u,p| [u,p] == ['u', 'x']}
+          basic_auth(:y) {|u,p| [u,p] == ['u', 'y']}
+          def x; end
+          def y; end
+          def z; end
         }
       end
 
       it 'returns "200 Ok" for un-protected methods' do
-        %w[put delete].each do |rqm|
-          send(rqm)
+        RocketIO::REQUEST_METHODS.values.each do |rqm|
+          send(rqm, :z)
           assert(last_response).ok?
         end
       end
 
       it 'returns "401 Unauthorized" if no authorization given' do
-        @protected.each do |rqm|
-          send(rqm)
-          assert(last_response).is_unauthorized
+        @protected.each do |m|
+          RocketIO::REQUEST_METHODS.values.each do |rqm|
+            send(rqm, m)
+            assert(last_response).is_unauthorized
+          end
         end
       end
 
       it 'returns "401 Unauthorized" if wrong authorization given' do
-        authorize('x', 'y')
-        @protected.each do |rqm|
-          send(rqm)
-          assert(last_response).is_unauthorized
+        authorize('', '')
+        @protected.each do |m|
+          RocketIO::REQUEST_METHODS.values.each do |rqm|
+            send(rqm, m)
+            assert(last_response).is_unauthorized
+          end
         end
       end
 
       it 'returns "200 Ok" response if authorization passed' do
-        authorize('u', 'get')
-        get
-        assert(last_response).ok?
+        authorize('u', 'x')
+        RocketIO::REQUEST_METHODS.values.each do |rqm|
+          send(rqm, :x)
+          assert(last_response).ok?
+        end
 
-        authorize('u', 'post')
-        post
-        assert(last_response).ok?
+        authorize('u', 'y')
+        RocketIO::REQUEST_METHODS.values.each do |rqm|
+          send(rqm, :y)
+          assert(last_response).ok?
+        end
       end
     end
   end
 
   context 'digest auth' do
     context 'hashed password' do
+
       before do
         app mock_controller {
           digest_auth(passwords_hashed: true) {|u| {'u' => '5daad7ee02f846df2874dba8f7522112'}[u]}
-          define_method(:get) {}
+          def index; end
         }
       end
 
@@ -236,7 +264,7 @@ spec :AuthenticationTest do
       before do
         app mock_controller {
           digest_auth {|u| {'u' => 'p'}[u]}
-          define_method(:get) {}
+          def index; end
         }
       end
 
@@ -258,49 +286,57 @@ spec :AuthenticationTest do
       end
     end
 
-    context 'protect specific request methods' do
+    context 'protect specific methods on any request method' do
+
       before do
-        @protected = %w[get post]
+        @protected = %w[x y]
         app mock_controller {
-          digest_auth(:get)  {|u| {'u' => 'get'}[u] }
-          digest_auth(:post) {|u| {'u' => 'post'}[u]}
-          define_method(:get) {}
-          define_method(:post) {}
-          define_method(:put) {}
-          define_method(:delete) {}
+          digest_auth(:x)  {|u| {'u' => 'x'}[u] }
+          digest_auth(:y) {|u| {'u' => 'y'}[u]}
+          def x; end
+          def y; end
+          def z; end
         }
       end
 
       it 'returns "200 Ok" for un-protected methods' do
-        %w[put delete].each do |rqm|
-          send(rqm)
+        RocketIO::REQUEST_METHODS.values.each do |rqm|
+          send(rqm, :z)
           assert(last_response).ok?
         end
       end
 
       it 'returns "401 Unauthorized" if no authorization given' do
-        @protected.each do |rqm|
-          send(rqm)
-          assert(last_response).is_unauthorized
+        @protected.each do |m|
+          RocketIO::REQUEST_METHODS.values.each do |rqm|
+            send(rqm, m)
+            assert(last_response).is_unauthorized
+          end
         end
       end
 
       it 'returns "401 Unauthorized" if wrong authorization given' do
-        digest_authorize('x', 'y')
-        @protected.each do |rqm|
-          send(rqm)
-          assert(last_response).is_unauthorized
+        digest_authorize('', '')
+        @protected.each do |m|
+          RocketIO::REQUEST_METHODS.values.each do |rqm|
+            send(rqm, m)
+            assert(last_response).is_unauthorized
+          end
         end
       end
 
       it 'returns "200 Ok" response if authorization passed' do
-        digest_authorize('u', 'get')
-        get
-        assert(last_response).ok?
+        digest_authorize('u', 'x')
+        RocketIO::REQUEST_METHODS.values.each do |rqm|
+          send(rqm, :x)
+          assert(last_response).ok?
+        end
 
-        digest_authorize('u', 'post')
-        post
-        assert(last_response).ok?
+        digest_authorize('u', 'y')
+        RocketIO::REQUEST_METHODS.values.each do |rqm|
+          send(rqm, :y)
+          assert(last_response).ok?
+        end
       end
     end
   end