rapid_api 0.1.0

data/test/unit/rapid_api/action_controller/rest_actions_test.rb

@@ -0,0 +1,160 @@
+require File.expand_path '../../../../test_helper.rb', __FILE__
+
+module ActionController
+
+  class RestActionsTest < ActionController::TestCase
+
+    class BricksController < ActionController::Base
+      include RapidApi::ActionController::RestActions
+
+      self.model_adapter      = TestModelAdapter
+      self.serializer_adapter = TestSerializerAdapter
+
+      permit_params     :color, :weight, :material
+      filterable_params :color
+
+      scope_by :color do |controller|
+        'blue'
+      end
+    end
+
+    Foo = Class.new(Brick)
+
+    tests BricksController
+
+    def test_model_class_name
+      assert_equal BricksController.model_class_name, "Brick"
+    end
+
+    def test_model
+      assert_equal Brick, BricksController.model
+      BricksController.model = Foo
+      assert_equal Foo, BricksController.model
+    end
+
+    def test_params_key
+      BricksController.model = Brick
+      assert_equal 'brick', BricksController.params_key
+      BricksController.params_key = 'foo'
+      assert_equal 'foo', BricksController.params_key
+      BricksController.params_key = 'brick'
+    end
+
+    def test_model_adapter
+      assert_equal TestModelAdapter, BricksController.model_adapter
+    end
+
+    def test_adapted_serializer
+      BricksController.serializer_adapter = TestSerializerAdapter
+      assert_equal TestSerializerAdapter, BricksController.serializer_adapter
+    end
+
+    def test_index
+      BricksController.adapted_model = Minitest::Mock.new
+      query_result = RapidApi::ModelAdapters::QueryResult.new(data: 'data')
+      BricksController.adapted_model.expect :find_all, query_result, [{'color' => 'green'}, {color: 'blue'}]
+      BricksController.adapted_serializer = Minitest::Mock.new
+      BricksController.adapted_serializer.expect :serialize_collection, nil, ['data']
+      get :index, {color: 'green', material: 'leaves'}
+      assert_response :ok
+      BricksController.adapted_model.verify
+      BricksController.adapted_serializer.verify
+    end
+
+    def test_show
+      BricksController.adapted_model = Minitest::Mock.new
+      query_result = RapidApi::ModelAdapters::QueryResult.new(data: 'data')
+      BricksController.adapted_model.expect :find, query_result, ["1", {color: 'blue'}]
+      BricksController.adapted_serializer = Minitest::Mock.new
+      BricksController.adapted_serializer.expect :serialize, nil, ['data']
+      get :show, {id: 1}
+      assert_response :ok
+      BricksController.adapted_model.verify
+      BricksController.adapted_serializer.verify
+    end
+
+    def test_show_not_found
+      BricksController.adapted_model = Minitest::Mock.new
+      query_result = RapidApi::ModelAdapters::QueryResult.new()
+      BricksController.adapted_model.expect :find, query_result, ["1", {color: 'blue'}]
+      get :show, {id: 1}
+      assert_response :not_found
+      BricksController.adapted_model.verify
+    end
+
+    def test_create
+      params = {'color' => 'red', 'weight' => '10', 'material' => 'clay'}
+      BricksController.adapted_model = Minitest::Mock.new
+      query_result = RapidApi::ModelAdapters::QueryResult.new(data: 'data')
+      BricksController.adapted_model.expect :create, query_result, [params, {color: 'blue'}]
+      BricksController.adapted_serializer = Minitest::Mock.new
+      BricksController.adapted_serializer.expect :serialize, nil, ['data']
+      post :create, {brick: params}
+      assert_response :created
+      BricksController.adapted_model.verify
+      BricksController.adapted_serializer.verify
+    end
+
+    def test_create_errors
+      params = {'color' => 'red', 'weight' => '10', 'material' => 'clay'}
+      BricksController.adapted_model = Minitest::Mock.new
+      query_result = RapidApi::ModelAdapters::QueryResult.new(data: 'data', errors: 'dummy error')
+      BricksController.adapted_model.expect :create, query_result, [params, {color: 'blue'}]
+      post :create, {brick: params}
+      assert_response :unprocessable_entity
+      assert_equal 'dummy error', JSON.parse(@controller.response.body)['errors']
+    end
+
+    def test_update
+      params = {'color' => 'red', 'weight' => '10', 'material' => 'clay'}
+      BricksController.adapted_model = Minitest::Mock.new
+      query_result = RapidApi::ModelAdapters::QueryResult.new(data: 'data')
+      BricksController.adapted_model.expect :update, query_result, ["1", params, {color: 'blue'}]
+      BricksController.adapted_serializer = Minitest::Mock.new
+      BricksController.adapted_serializer.expect :serialize, nil, ['data']
+      post :update, {brick: params, id: 1}
+      assert_response :ok
+      BricksController.adapted_model.verify
+      BricksController.adapted_serializer.verify
+    end
+
+    def test_update_not_found
+      params = {'color' => 'red', 'weight' => '10', 'material' => 'clay'}
+      BricksController.adapted_model = Minitest::Mock.new
+      query_result = RapidApi::ModelAdapters::QueryResult.new()
+      BricksController.adapted_model.expect :update, query_result, ["1", params, {color: 'blue'}]
+      post :update, {brick: params, id: 1}
+      assert_response :not_found
+      BricksController.adapted_model.verify
+    end
+
+    def test_update_errors
+      params = {'color' => 'red', 'weight' => '10', 'material' => 'clay'}
+      BricksController.adapted_model = Minitest::Mock.new
+      query_result = RapidApi::ModelAdapters::QueryResult.new(data: 'data', errors: 'dummy error')
+      BricksController.adapted_model.expect :update, query_result, ["1", params, {color: 'blue'}]
+      post :update, {brick: params, id: 1}
+      assert_response :unprocessable_entity
+      BricksController.adapted_model.verify
+    end
+
+    def test_destroy
+      BricksController.adapted_model = Minitest::Mock.new
+      query_result = RapidApi::ModelAdapters::QueryResult.new()
+      BricksController.adapted_model.expect :destroy, query_result, ["1", {color: 'blue'}]
+      post :destroy, {id: 1}
+      assert_response :no_content
+      BricksController.adapted_model.verify
+    end
+
+    def test_destroy_errors
+      BricksController.adapted_model = Minitest::Mock.new
+      query_result = RapidApi::ModelAdapters::QueryResult.new(errors: 'dummy error')
+      BricksController.adapted_model.expect :destroy, query_result, ["1", {color: 'blue'}]
+      post :destroy, {id: 1}
+      assert_response :unprocessable_entity
+      BricksController.adapted_model.verify
+    end
+  end
+
+end

data/test/unit/rapid_api/action_controller/scope_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path '../../../../test_helper.rb', __FILE__
+
+module ActionController
+
+  class ScopeTest < ActionController::TestCase
+
+    class TestScopesController < ActionController::Base
+      include RapidApi::ActionController::Scope
+
+      scope_by :user_id, :org_id do |controller|
+        [controller.params['user_id'], controller.params['org_id']]
+      end
+
+      def scoped_bricks
+        render json: scope.to_json, status: :ok
+      end
+    end
+
+    tests TestScopesController
+
+    def test_scope_by
+      get :scoped_bricks, { user_id: 1, org_id: 2 }
+      body = JSON.parse(@controller.response.body)
+      assert_equal '1', body['user_id']
+      assert_equal '2', body['org_id']
+    end
+  end
+
+end

data/test/unit/rapid_api/auth/concerns/authenticated_controller_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path '../../../../../test_helper.rb', __FILE__
+
+class AuthenticatedControllerTest < ActionController::TestCase
+
+  class TestAuthenticatedController < ActionController::Base
+    include RapidApi::ActionController::Errors
+    include RapidApi::Auth::Concerns::AuthenticatedController
+
+    rapid_actions model: Brick, serializer: BrickSerializer
+
+    permit_params :color, :weight, :material
+
+    authenticate do |controller|
+      token = controller.decode_jwt_token!(controller.request.headers.env['Authorization'])
+      user_id = token[0].try :[], 'user_id'
+      if user_id.present?
+        User.find user_id
+      else
+        nil
+      end
+    end
+  end
+
+  TestChildAuthenticatedController = Class.new TestAuthenticatedController
+
+  tests TestAuthenticatedController
+
+  def setup
+    super
+    DatabaseCleaner.start
+  end
+
+  def teardown
+    DatabaseCleaner.clean
+  end
+
+  def test_authenticated
+    @user = User.create
+    token = RapidApi::Auth::Support::JWT.encode({ user_id: @user.id })
+    @request.env['Authorization'] = token
+    get :index
+    assert_response :ok
+    assert_equal @controller.authenticated.id, @user.id
+  end
+
+  def test_not_authenticated_without_user
+    User.delete_all
+    get :index
+    assert_response :unauthorized
+  end
+
+  def test_child_controller
+    assert_equal TestAuthenticatedController.authenticate_proc, TestChildAuthenticatedController.authenticate_proc
+  end
+
+end

data/test/unit/rapid_api/auth/concerns/sessions_controller_test.rb

@@ -0,0 +1,55 @@
+require File.expand_path '../../../../../test_helper.rb', __FILE__
+
+class SessionsControllerTest < ActionController::TestCase
+
+  class TestSessionsController < ActionController::Base
+    include RapidApi::Auth::Concerns::SessionsController
+
+    authenticates_with :username, :password do |params|
+      User.where(username: params[:username], password: params[:password]).first
+    end
+
+    responds_with do |authenticated|
+      {
+        token: jwt_encode({ secret: 'foo' }),
+        user: {
+          id:       authenticated.id,
+          username: authenticated.username
+        }
+      }
+    end
+  end
+
+  tests TestSessionsController
+
+  def setup
+    super
+    DatabaseCleaner.start
+
+    @user = User.create username: 'bob_the_builder', password: 'password'
+  end
+
+  def teardown
+    DatabaseCleaner.clean
+  end
+
+  def test_authenticate
+    params = {'username' => 'bob_the_builder', 'password' => 'password'}
+    post :authenticate, params
+    body = JSON.parse(@controller.response.body)
+    assert_response :ok
+    decoded_token = RapidApi::Auth::Support::JWT.decode(body["token"])
+    assert_equal decoded_token[0]['secret'], 'foo'
+    assert_equal body["user"]["id"], @user.id
+    assert_equal body["user"]["username"], @user.username
+  end
+
+  def test_invalid_credentials
+    params = {'username' => 'bob_the_builder', 'password' => 'wrong_password'}
+    post :authenticate, params
+    body = JSON.parse(@controller.response.body)
+    assert_response :unauthorized
+    assert_equal body["errors"].first, 'Invalid credentials'
+  end
+
+end

data/test/unit/rapid_api/auth/support/jwt_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path '../../../../../test_helper.rb', __FILE__
+
+class JwtTest < Minitest::Test
+
+  def setup
+    super
+    @subject = RapidApi::Auth::Support::JWT
+  end
+
+  def teardown
+    super
+  end
+
+  def test_encode
+    payload = { user_id: 1 }
+    refute_equal @subject.encode(payload), nil
+  end
+
+  def test_decode
+    payload = { user_id: 1, secret: 'secret' }
+    token   = @subject.encode(payload)
+
+    decoded_token = @subject.decode(token)
+    assert_equal decoded_token[0]['secret'], 'secret'
+    assert_equal decoded_token[1]['alg'],    'none'
+  end
+
+end

data/test/unit/rapid_api/model_adapters/abstract_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path '../../../../test_helper.rb', __FILE__
+
+module RapidApi
+  module ModelAdapters
+    class AbstractModelAdapterTest < Minitest::Test
+      def setup
+        @adapter = RapidApi::ModelAdapters::Abstract.new(nil)
+      end
+
+      def teardown
+
+      end
+
+      def test_find
+        assert_raises NotImplementedError do
+          @adapter.find(nil, nil)
+        end
+      end
+
+      def test_find_all
+        assert_raises NotImplementedError do
+          @adapter.find_all(nil, nil)
+        end
+      end
+
+      def test_create
+        assert_raises NotImplementedError do
+          @adapter.create(nil, nil)
+        end
+      end
+
+      def test_update
+        assert_raises NotImplementedError do
+          @adapter.update(nil, nil)
+        end
+      end
+
+      def test_destroy
+        assert_raises NotImplementedError do
+          @adapter.destroy(nil, nil)
+        end
+      end
+    end
+  end
+end

data/test/unit/rapid_api/model_adapters/active_record_adapter_test.rb

@@ -0,0 +1,121 @@
+require File.expand_path '../../../../test_helper.rb', __FILE__
+
+module RapidApi
+  module ModelAdapters
+    class ActiveRecordAdapterTest < Minitest::Test
+
+      def setup
+        DatabaseCleaner.start
+        @adapter = RapidApi::ModelAdapters::ActiveRecordAdapter.new(Brick)
+      end
+
+      def teardown
+        DatabaseCleaner.clean
+      end
+
+      def test_adapted_klass
+        assert_equal Brick, @adapter.klass
+      end
+
+      def test_find
+        brick = Brick.create color: 'red1'
+        query_result = @adapter.find(brick.id)
+        assert_equal brick, query_result.data
+      end
+
+      def test_find_all
+        Brick.delete_all
+        brick1 = Brick.create color: 'blue'
+        brick2 = Brick.create color: 'green'
+        query_result = @adapter.find_all
+        assert_equal [brick1.id, brick2.id],  query_result.data.map(&:id)
+      end
+
+      def test_create
+        params = {color: 'red2', weight: 1, material: 'clay'}
+        query_result = @adapter.create params
+        assert_equal 'red2', query_result.data.color
+        assert_equal 1,      query_result.data.weight
+        assert_equal 'clay', query_result.data.material
+        refute_equal nil,    query_result.data.id
+      end
+
+      def test_create_errors
+        params = {color: 'red3', weight: 1, material: 'clay'}
+        @adapter.create params
+        query_result = @adapter.create params
+        assert_equal true, query_result.has_errors?
+      end
+
+      def test_update
+        params        = {color: 'red4',    weight: 1,  material: 'clay'}
+        update_params = {color: 'yellow1', weight: 10, material: 'gold'}
+        brick         = Brick.create params
+        query_result = @adapter.update(brick.id, update_params)
+        assert_equal 'yellow1', query_result.data.color
+        assert_equal 10,       query_result.data.weight
+        assert_equal 'gold',   query_result.data.material
+        assert_equal brick.id, query_result.data.id
+      end
+
+      def test_update_errors
+        params        = {color: 'red5',    weight: 1,  material: 'clay'}
+        update_params = {color: 'yellow2', weight: 10, material: 'gold'}
+        brick         = Brick.create params
+        Brick.create update_params
+        query_result = @adapter.update(brick.id, update_params)
+        assert_equal true, query_result.has_errors?
+      end
+
+      def test_destroy
+        params = {color: 'red6',    weight: 1,  material: 'clay'}
+        brick  = Brick.create params
+        @adapter.destroy brick.id
+        assert Brick.where(id: brick.id).empty?
+      end
+
+      def test_destroy_errors
+        params = {color: 'prevent_destroy', weight: 1,  material: 'clay'}
+        brick  = Brick.create params
+        query_result = @adapter.destroy brick.id
+        assert_equal true, query_result.has_errors?
+      end
+
+      def test_find_with_scope
+        brick = Brick.create color: 'magenta'
+        query_result = @adapter.find(brick.id, {color: 'orange'})
+        assert_equal nil, query_result.data
+        query_result = @adapter.find(brick.id, {color: 'magenta'})
+        assert_equal brick, query_result.data
+      end
+
+      def test_find_all_with_scope
+        Brick.delete_all
+        brick1 = Brick.create color: 'blue'
+        brick2 = Brick.create color: 'green'
+        params = {color: 'green'}
+        scope  = {color: 'blue'}
+        query_result = @adapter.find_all params, scope
+        assert_equal [brick1.id],  query_result.data.map(&:id)
+      end
+
+      def test_create_with_scope
+        params = {color: 'lavender', weight: 1, material: 'clay'}
+        query_result = @adapter.create params, {weight: 2, material: 'flowers'}
+        assert_equal 'lavender',  query_result.data.color
+        assert_equal 2,           query_result.data.weight
+        assert_equal 'flowers',   query_result.data.material
+        refute_equal nil,         query_result.data.id
+      end
+
+      def test_find_all_with_params
+        Brick.delete_all
+        brick1 = Brick.create color: 'blue'
+        brick2 = Brick.create color: 'green'
+        params = {color: 'green'}
+        query_result = @adapter.find_all params
+        assert_equal [brick2.id],  query_result.data.map(&:id)
+      end
+    end
+  end
+end

data/test/unit/rapid_api/serializer_adapters/abstract_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path '../../../../test_helper.rb', __FILE__
+
+module RapidApi
+  module SerializerAdapters
+    class AbstractAdapterTest < Minitest::Test
+      def setup
+        @adapter = RapidApi::SerializerAdapters::Abstract.new(nil, nil)
+      end
+
+      def teardown
+
+      end
+
+      def test_serialize
+        assert_raises NotImplementedError do
+          @adapter.serialize(nil)
+        end
+      end
+
+      def test_serialize_collection
+        assert_raises NotImplementedError do
+          @adapter.serialize_collection(nil)
+        end
+      end
+    end
+  end
+end

data/test/unit/rapid_api/serializer_adapters/ams_adapter_test.rb

@@ -0,0 +1,31 @@
+require File.expand_path '../../../../test_helper.rb', __FILE__
+
+module RapidApi
+  module SerializerAdapters
+    class AmsAdapterTest < Minitest::Test
+
+      def setup
+        @adapter = RapidApi::SerializerAdapters::AmsAdapter.new(BrickSerializer, "brick")
+      end
+
+      def test_klass
+        assert_equal BrickSerializer, @adapter.klass
+      end
+
+      def test_serialize
+        brick = Brick.create color: 'yellow', weight: 10, material: 'gold'
+        serialized_brick = @adapter.serialize brick
+        assert_equal "{\"brick\":{\"color\":\"yellow\",\"weight\":\"10.0\",\"material\":\"gold\"}}", serialized_brick
+      end
+
+      def test_serialize_collection
+        Brick.destroy_all
+        brick1 = Brick.create color: 'yellow', weight: 10, material: 'gold'
+        brick2 = Brick.create color: 'red',    weight: 1,  material: 'clay'
+        serialized_brick_array = @adapter.serialize_collection Brick.all
+        assert_equal "{\"bricks\":[{\"color\":\"yellow\",\"weight\":\"10.0\",\"material\":\"gold\"},{\"color\":\"red\",\"weight\":\"1.0\",\"material\":\"clay\"}]}", serialized_brick_array
+      end
+
+    end
+  end
+end

data/test/unit/rapid_api/test_configuration.rb

@@ -0,0 +1,17 @@
+require File.expand_path '../../test_helper.rb', __FILE__
+
+class ConfigurationTest < Minitest::Test
+
+  DefaultModelAdapter = Class.new(RapidApi::ModelAdapters::Abstract)
+  RapidApi.config.model_adapter = DefaultModelAdapter
+
+  class BricksController < ActionController::Base
+    include RapidApi::ActionController::RestActions
+
+    permit_params :color
+  end
+
+  def test_default_model_adapter
+    assert_equal DefaultModelAdapter, BricksController.model_adapter
+  end
+end