standardapi 5.0.0.4 → 5.0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ffafde0be5ac4af61ae465486cc2b425ee97274
-  data.tar.gz: 90e2e0e35898cee9bb550c2378f8708166512f06
+  metadata.gz: 7ddf2593f95bb453a53bca52257c21509a8a4042
+  data.tar.gz: f589c7fb725ea99636d6a04112fe83cf0647dc26
 SHA512:
-  metadata.gz: a080f851a213f0759fe8d9554e65588135169a5f99ca72ee52239917c8082f9420490b17d5cb2d3f5df41e0c50babb33c7ac56ac23a50fffe0cc99ce5b67ba7d
-  data.tar.gz: 3bef590610082ecf5de5042b16e16dc4e5b558de7cfd65f0426e8a12b54119793497695acaa9819cde7bdf77303c625540a2c3f87da8c2521a3a5cfb4bcce410
+  metadata.gz: 1ec52191db1bfbc6bb3309f33b4870e26f964402a70e21a840e8f5e22847e9be76c7f9c86be6fd65131815e1a757c5b23e9e28e3f8ad1e8d789b28500bf932e0
+  data.tar.gz: 746e50e142dc29c8bea3ef2e9af5351b0f0887a850ed41804bbcdfeffb5a7eab59f71757392c8b3415be237f43b17aec703a7ebfc4f6b30611bfc29370081636

data/lib/standard_api/controller.rb

@@ -2,26 +2,14 @@ module StandardAPI
   module Controller
 
     def self.included(klass)
-      klass.helper_method :includes, :orders, :model
+      klass.helper_method :includes, :orders, :model, :resource_limit
+      klass.before_action :set_standardapi_headers
       klass.append_view_path(File.join(File.dirname(__FILE__), 'views'))
       klass.extend(ClassMethods)
     end
-    
-    def ping
-      render plain: 'pong'
-    end
-
-    def tables
-      controllers = Dir[Rails.root.join('app/controllers/*_controller.rb')].map{ |path| path.match(/(\w+)_controller.rb/)[1].camelize+"Controller" }.map(&:safe_constantize)
-      controllers.select! { |c| c.ancestors.include?(self.class) && c != self.class }
-      controllers.map!(&:model).compact!
-      controllers.map!(&:table_name)
-    
-      render json: controllers
-    end  
 
     def index
-      instance_variable_set("@#{model.model_name.plural}", resources.limit(params[:limit]).offset(params[:offset]).sort(orders))
+      instance_variable_set("@#{model.model_name.plural}", resources.limit(limit).offset(params[:offset]).sort(orders))
     end
 
     def calculate
@@ -94,33 +82,45 @@ module StandardAPI
         @model = name.sub(/Controller\z/, '').singularize.camelize.safe_constantize
       end
 
+      def model_includes
+        if self.respond_to?("#{model.model_name.singular}_includes", true)
+          self.send "#{model.model_name.singular}_includes"
+        else
+          []
+        end
+      end
+
+      def model_orders
+        if self.respond_to?("#{model.model_name.singular}_orders", true)
+          self.send "#{model.model_name.singular}_orders"
+        else
+          []
+        end
+      end
+
     end
-  
+
     private
 
-    def model
-      self.class.model
+    def set_standardapi_headers
+      headers['StandardAPI-Version'] = StandardAPI::VERSION
     end
 
-    def model_params
-      if self.respond_to?("#{model.model_name.singular}_params", true)
-        params.require(model.model_name.singular).permit(self.send("#{model.model_name.singular}_params"))
-      else
-        []
-      end
+    def model
+      self.class.model
     end
 
     def model_includes
-      if self.respond_to?("#{model.model_name.singular}_includes", true)
-        self.send "#{model.model_name.singular}_includes"
-      else
-        []
-      end
+      self.class.model_includes
     end
 
     def model_orders
-      if self.respond_to?("#{model.model_name.singular}_orders", true)
-        self.send "#{model.model_name.singular}_orders"
+      self.class.model_orders
+    end
+
+    def model_params
+      if self.respond_to?("#{model.model_name.singular}_params", true)
+        params.require(model.model_name.singular).permit(self.send("#{model.model_name.singular}_params"))
       else
         []
       end
@@ -140,7 +140,15 @@ module StandardAPI
     end
 
     def resources
-      model.filter(params[:where]).filter(current_mask[model.table_name])
+      query = model.filter(params[:where]).filter(current_mask[model.table_name])
+      
+      if params[:distinct_on]
+        query.distinct_on(params[:distinct_on])
+      elsif params[:distinct]
+        query.distinct
+      else
+        query
+      end
     end
 
     def includes
@@ -185,6 +193,25 @@ module StandardAPI
       @excludes ||= model_excludes
     end
 
+    # The maximum number of results returned by #index
+    def resource_limit
+      1000
+    end
+
+    def limit
+      if resource_limit
+        limit = params.require(:limit).to_i
+
+        if limit > resource_limit
+          raise ActionController::UnpermittedParameters.new([:limit, limit])
+        end
+
+        limit
+      else
+        params.permit(:limit)[:limit]
+      end
+    end
+
     # Used in #calculate
     # [{ count: :id }]
     # [{ count: '*' }]

data/lib/standard_api/test_case/calculate_tests.rb

@@ -7,9 +7,10 @@ module StandardAPI
         create_model
         selects = [{ count: :id}, { maximum: :id }, { minimum: :id }, { average: :id }]
 
-        get :calculate, params: {select: selects}, format: :json
+        get resource_path(:calculate, select: selects, format: :json)
         assert_response :ok
-        assert_equal [[model.count(:id), model.maximum(:id), model.minimum(:id), model.average(:id).to_f]], assigns(:calculations)
+        calculations = @controller.instance_variable_get('@calculations')
+        assert_equal [[model.count(:id), model.maximum(:id), model.minimum(:id), model.average(:id).to_f]], calculations
       end
 
       test '#calculate.json params[:where]' do
@@ -19,27 +20,32 @@ module StandardAPI
         selects = [{ count: :id}, { maximum: :id }, { minimum: :id }, { average: :id }]
         predicate = { id: { gt: m1.id } }
 
-        get :calculate, params: {where: predicate, select: selects}, format: :json
+        get resource_path(:calculate, where: predicate, select: selects, format: :json)
+
         assert_response :ok
         assert_equal [[
           model.filter(predicate).count(:id),
           model.filter(predicate).maximum(:id),
           model.filter(predicate).minimum(:id),
           model.filter(predicate).average(:id).to_f
-        ]], assigns(:calculations)
+        ]], @controller.instance_variable_get('@calculations')
       end
 
       test '#calculate.json mask' do
+        # This is just to instance @controller
+        get resource_path(:calculate)
+
         # If #current_mask isn't defined by StandardAPI we don't know how to
         # test other's implementation of #current_mask. Return and don't test.
         return if @controller.method(:current_mask).owner != StandardAPI
 
         m = create_model
+
         @controller.current_mask[plural_name] = { id: m.id + 100 }
         selects = [{ count: :id}, { maximum: :id }, { minimum: :id }, { average: :id }]
         get :calculate, select: selects, format: 'json'
         assert_response :ok
-        assert_equal [[0, nil, nil, nil]], assigns(:calculations)
+        assert_equal [[0, nil, nil, nil]], @controller.instance_variable_get('@calculations')
         @controller.current_mask.delete(plural_name)
       end
 

data/lib/standard_api/test_case/create_tests.rb

@@ -3,24 +3,18 @@ module StandardAPI
     module CreateTests
       extend ActiveSupport::Testing::Declarative
 
-      def setup
-        @request.content_type="application/json"
-        super
-      end
-      
       test '#create.json' do
         attrs = attributes_for(singular_name, :nested).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
         create_webmocks(attrs)
 
         assert_difference("#{model.name}.count") do
-          post :create, params: {singular_name => attrs}, format: :json
+          post resource_path(:create, singular_name => attrs, format: :json)
           assert_response :created
-          assert assigns(singular_name)
+          m = @controller.instance_variable_get("@#{singular_name}")
 
           json = JSON.parse(response.body)
           assert json.is_a?(Hash)
 
-          m = assigns(singular_name)
           view_attributes(m.reload).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
             message = "Model / Attribute: #{m.class.name}##{key}"
             if value.is_a?(BigDecimal)
@@ -37,13 +31,14 @@ module StandardAPI
         create_webmocks(attrs)
 
         assert_difference("#{model.name}.count") do
-          post :create, params: {singular_name => attrs}, format: :json
+          post resource_path(:create, format: :json), params: {singular_name => attrs}
           assert_response :created
-          assert assigns(singular_name)
+          m = @controller.instance_variable_get("@#{singular_name}")
+          assert m
 
           json = JSON.parse(response.body)
           assert json.is_a?(Hash)
-          m = assigns(singular_name).reload
+          m.reload
           view_attributes(m).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
             message = "Model / Attribute: #{m.class.name}##{key}"
             assert_equal normalize_attribute(m, key, attrs[key.to_sym]), value, message
@@ -64,14 +59,14 @@ module StandardAPI
         create_webmocks(attrs)
 
         assert_difference("#{model.name}.count", 0) do
-          post :create, params: {singular_name => attrs}, format: :json
+          post resource_path(:create, singular_name => attrs, format: :json)
           assert_response :bad_request
           json = JSON.parse(response.body)
           assert json.is_a?(Hash)
           assert json['errors']
         end
       end
-      
+
       test '#create.html with invalid attributes renders edit action' do
         return unless supports_format(:html)
 
@@ -87,7 +82,7 @@ module StandardAPI
         create_webmocks(attrs)
 
         assert_difference("#{model.name}.count", 0) do
-          post :create, params: {singular_name => attrs}, format: :html
+          post resource_path(:create, singular_name => attrs, format: :html)
           assert_response :bad_request
           assert_equal response.body, 'properties#edit.html'
         end
@@ -99,24 +94,25 @@ module StandardAPI
           create_webmocks(attrs)
 
           assert_difference("#{model.name}.count") do
-            post :create, params: {singular_name => attrs, :include => includes}, format: :json
+            post resource_path(:create, singular_name => attrs, include: includes, format: :json)
             assert_response :created
-            assert assigns(singular_name)
+            m = @controller.instance_variable_get("@#{singular_name}")
+            assert m
 
             json = JSON.parse(response.body)
             assert json.is_a?(Hash)
             includes.each do |included|
               assert json.key?(included.to_s), "#{included.inspect} not included in response"
 
-              association = assigns(singular_name).class.reflect_on_association(included)
+              association = m.class.reflect_on_association(included)
               next if !association
 
               if ['belongs_to', 'has_one'].include?(association.macro.to_s)
-                view_attributes(assigns(singular_name).send(included)) do |key, value|
-                  assert_equal json[included.to_s][key.to_s], normalize_to_json(assigns(singular_name), key, value)
+                view_attributes(m.send(included)) do |key, value|
+                  assert_equal json[included.to_s][key.to_s], normalize_to_json(m, key, value)
                 end
               else
-                m = assigns(singular_name).send(included).first.try(:reload)
+                m = m.send(included).first.try(:reload)
 
                 m_json = if m && m.has_attribute?(:id)
                   json[included.to_s].find { |x| x['id'] == normalize_to_json(m, :id, m.id) }

data/lib/standard_api/test_case/destroy_tests.rb

@@ -7,21 +7,25 @@ module StandardAPI
         m = create_model
 
         assert_difference("#{model.name}.count", -1) do
-          delete :destroy, params: { id: m.id }, format: :json
+          delete resource_path(:destroy, id: m.id, format: :json)
           assert_response :no_content
           assert_equal '', response.body
         end
       end
 
       test '#destroy.json mask' do
+        m = create_model
+
+        # This is just to instance @controller
+        get resource_path(:show, id: m.id, format: 'json')
+
         # If #current_mask isn't defined by StandardAPI we don't know how to
         # test other's implementation of #current_mask. Return and don't test.
         return if @controller.method(:current_mask).owner != StandardAPI
 
-        m = create_model
         @controller.current_mask[plural_name] = { id: m.id + 1 }
         assert_raises(ActiveRecord::RecordNotFound) do
-          delete :destroy, params: { id: m.id }, format: :json
+          delete resource_path(:destroy, id: m.id, format: :json)
         end
         @controller.current_mask.delete(plural_name)
       end

data/lib/standard_api/test_case/index_tests.rb

@@ -4,58 +4,80 @@ module StandardAPI
       extend ActiveSupport::Testing::Declarative
 
       test '#index.json' do
-        get :index, format: :json
+        get resource_path(:index, format: :json), params: { limit: 10 }
         assert_response :ok
-        assert_equal model.all.map(&:id).sort, assigns(plural_name).map(&:id).sort
+        models = @controller.instance_variable_get("@#{plural_name}")
+        assert_equal model.all.map(&:id).sort, models.map(&:id).sort
         assert JSON.parse(response.body).is_a?(Array)
       end
 
+      test '#index.json requires limit' do
+        assert_raises ActionController::ParameterMissing do
+          get resource_path(:index, format: :json)
+        end
+      end
+
       test '#index.json params[:limit]' do
-        get :index, params: { limit: 1 }, format: :json
-        assert_equal model.limit(1).sort(required_orders).to_sql, assigns(plural_name).to_sql
+        get resource_path(:index, format: :json), params: { limit: 1 }
+        models = @controller.instance_variable_get("@#{plural_name}")
+        assert_equal model.limit(1).sort(required_orders).to_sql, models.to_sql
+      end
+
+      test '#index.json params[:limit] does not exceed maximum limit' do
+        assert_raises ActionController::UnpermittedParameters do
+          get resource_path(:index, format: :json), params: { limit: 1000000 }
+        end
       end
 
       test '#index.json params[:where]' do
         m = create_model
 
-        get :index, params: { where: { id: m.id } }, format: :json
-        assert_equal [m], assigns(plural_name)
+        get resource_path(:index, format: :json), params: { limit: 10, where: { id: m.id } }
+        models = @controller.instance_variable_get("@#{plural_name}")
+        assert_equal [m], models
       end
 
       test '#index.json params[:order]' do
+        # This is just to instance @controller
+        get resource_path(:index, format: :json), params: { limit: 1 }
+
         orders.each do |order|
           @controller.instance_variable_set('@orders', nil) # Hack for dealing with caching / multiple request per controller life
-          get :index, params: { order: order }, format: :json
-          assert_equal model.sort(order).sort(required_orders).to_sql, assigns(plural_name).to_sql
+          get resource_path(:index, format: :json), params: { limit: 10, order: order }
+          models = @controller.instance_variable_get("@#{plural_name}")
+          assert_equal model.sort(order).limit(10).sort(required_orders).to_sql, models.to_sql
          end
       end
 
       test '#index.json params[:offset]' do
-        get :index, params: { offset: 13 }, format: :json
-        assert_equal model.offset(13).sort(required_orders).to_sql, assigns(plural_name).to_sql
+        get resource_path(:index, format: :json), params: { limit: 10, offset: 13 }
+        models = @controller.instance_variable_get("@#{plural_name}")
+        assert_equal model.offset(13).limit(10).sort(required_orders).to_sql, models.to_sql
       end
 
       test '#index.json params[:include]' do
         travel_to Time.now do
           create_model
-          get :index, params: { include: includes }, format: :json
+          get resource_path(:index, format: :json), params: { limit: 100, include: includes }
         
           json = JSON.parse(response.body)[0]
           assert json.is_a?(Hash)
           includes.each do |included|
             assert json.key?(included.to_s), "#{included.inspect} not included in response"
 
-            association = assigns(plural_name).first.class.reflect_on_association(included)
+            models = @controller.instance_variable_get("@#{plural_name}")
+            association = models.first.class.reflect_on_association(included)
             next if !association
 
             if ['belongs_to', 'has_one'].include?(association.macro.to_s)
-              m = assigns(plural_name).first.send(included)
+              models = @controller.instance_variable_get("@#{plural_name}")
+              m = models.first.send(included)
               view_attributes(m) do |key, value|
                 message = "Model / Attribute: #{m.class.name}##{key}"
                 assert_equal json[included.to_s][key.to_s], normalize_to_json(m, key, value), message
               end
             else
-              m = assigns(plural_name).first.send(included).first.try(:reload)
+              m = models.first.send(included).first.try(:reload)
 
               m_json = if m && m.has_attribute?(:id)
                 json[included.to_s].find { |x| x['id'] == normalize_to_json(m, :id, m.id) }
@@ -76,6 +98,9 @@ module StandardAPI
       end
 
       test '#index.json mask' do
+        # This is just to instance @controller
+        get resource_path(:index, format: :json), params: { limit: 1 }
+
         # If #current_mask isn't defined by StandardAPI we don't know how to
         # test other's implementation of #current_mask. Return and don't test.
         return if @controller.method(:current_mask).owner != StandardAPI
@@ -83,7 +108,8 @@ module StandardAPI
         m = create_model
         @controller.current_mask[plural_name] = { id: m.id }
         get :index, format: :json
-        assert_equal model.where(id: m.id).sort(required_orders).to_sql, assigns(plural_name).to_sql
+        models = @controller.instance_variable_get("@#{plural_name}")
+        assert_equal model.where(id: m.id).sort(required_orders).to_sql, models.to_sql
         @controller.current_mask.delete(plural_name)
       end
     end

data/lib/standard_api/test_case/new_tests.rb

@@ -4,9 +4,9 @@ module StandardAPI
       extend ActiveSupport::Testing::Declarative
 
       test '#new.json' do
-        get :new, format: 'json'
+        get resource_path(:new, format: 'json')
         assert_response :ok
-        assert assigns(singular_name)
+        assert @controller.instance_variable_get("@#{singular_name}")
       end
 
     end

data/lib/standard_api/test_case/schema_tests.rb

@@ -0,0 +1,21 @@
+module StandardAPI
+  module TestCase
+    module IndexTests
+      extend ActiveSupport::Testing::Declarative
+
+      test '#schema.json' do
+        create_model
+
+        get resource_path(:schema, format: :json)
+        assert_response :ok
+        json = JSON(@response.body)
+        assert json['columns']
+        model.columns.map do |column|
+          assert json['columns'][column.name]['type']
+        end
+        assert json['limit']
+      end
+
+    end
+  end
+end

data/lib/standard_api/test_case/show_tests.rb

@@ -6,29 +6,29 @@ module StandardAPI
       test '#show.json' do
         m = create_model
 
-        get :show, params: {id: m.id}, format: :json
+        get resource_path(:show, id: m.id, format: :json)
         assert_response :ok
-        assert_equal m, assigns(singular_name)
+        assert_equal m, @controller.instance_variable_get("@#{singular_name}")
         assert JSON.parse(response.body).is_a?(Hash)
       end
 
       test '#show.json params[:include]' do
         m = create_model
-        get :show, params: {id: m.id, include: includes}, format: :json
+        get resource_path(:show, id: m.id, include: includes, format: :json)
 
         json = JSON.parse(response.body)
         includes.each do |included|
           assert json.key?(included.to_s), "#{included.inspect} not included in response"
 
-          association = assigns(singular_name).class.reflect_on_association(included)
+          association = @controller.instance_variable_get("@#{singular_name}").class.reflect_on_association(included)
           next if !association
 
           if ['belongs_to', 'has_one'].include?(association.macro.to_s)
-            view_attributes(assigns(singular_name).send(included)) do |key, value|
+            view_attributes(@controller.instance_variable_get("@#{singular_name}").send(included)) do |key, value|
               assert_equal json[included.to_s][key.to_s], value
             end
           else
-            m = assigns(singular_name).send(included).first.try(:reload)
+            m = @controller.instance_variable_get("@#{singular_name}").send(included).first.try(:reload)
             
             m_json = if m && m.has_attribute?(:id)
               json[included.to_s].find { |x| x['id'] == normalize_to_json(m, :id, m.id) }
@@ -48,14 +48,19 @@ module StandardAPI
       end
 
       test '#show.json mask' do
+        m = create_model
+
+        # This is just to instance @controller
+        get resource_path(:show, id: m.id, format: :json)
+
         # If #current_mask isn't defined by StandardAPI we don't know how to
         # test other's implementation of #current_mask. Return and don't test.
         return if @controller.method(:current_mask).owner != StandardAPI
 
-        m = create_model
+
         @controller.current_mask[plural_name] = { id: m.id + 1 }
         assert_raises(ActiveRecord::RecordNotFound) do
-          get :show, params: {id: m.id}, format: :json
+          get resource_path(:show, id: m.id, format: :json)
         end
         @controller.current_mask.delete(plural_name)
       end

data/lib/standard_api/test_case/update_tests.rb

@@ -3,17 +3,12 @@ module StandardAPI
     module UpdateTests
       extend ActiveSupport::Testing::Declarative
 
-      def setup
-        @request.content_type="application/json"
-        super
-      end
-      
       test '#update.json' do
         m = create_model
         attrs = attributes_for(singular_name).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
         create_webmocks(attrs)
 
-        put :update, params: {:id => m.id, singular_name => attrs}, format: :json
+        put resource_path(:update, :id => m.id, :format => 'json'), params: { singular_name => attrs }
         assert_response :ok, "Updating #{m.class.name} with #{attrs.inspect}"
 
         view_attributes(m.reload).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
@@ -28,13 +23,18 @@ module StandardAPI
       end
 
       test '#update.html redirects to #show.html' do
+        m = create_model
+
+        # This is just to instance @controller
+        get resource_path(:show, id: m.id, format: :json)
+
         return if @controller.method(:update).owner != StandardAPI
         
-        m = create_model
         attrs = attributes_for(singular_name).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
         create_webmocks(attrs)
 
-        put :update, params: {:id => m.id, singular_name => attrs}, format: :html
+        put resource_path(:update, :id => m.id, :format => 'html'), params: { singular_name => attrs }
+
         assert_redirected_to m
       end
 
@@ -42,7 +42,8 @@ module StandardAPI
         m = create_model
         attrs = attributes_for(singular_name, :nested).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
         create_webmocks(attrs)
-        put :update, params: {:id => m.id, singular_name => attrs}, format: :json
+
+        put resource_path(:update, :id => m.id, :format => 'json'), params: { singular_name => attrs }
         assert_response :ok, "Updating #{m.class.name} with #{attrs.inspect}"
 
         # (m.attribute_names & attrs.keys.map(&:to_s)).each do |test_key|
@@ -66,7 +67,7 @@ module StandardAPI
         attrs = attributes_for(singular_name, :invalid).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
         create_webmocks(attrs)
 
-        put :update, params: {:id => m.id, singular_name => attrs}, format: :json
+        put resource_path(:update, :id => m.id, :format => 'json'), params: { singular_name => attrs }
         assert_response :bad_request, "Updating #{m.class.name} with invalid attributes #{attrs.inspect}"
         assert JSON.parse(@response.body)['errors']
       end
@@ -77,23 +78,24 @@ module StandardAPI
           attrs = attributes_for(singular_name, :nested).select{|k,v| !model.readonly_attributes.include?(k) }
           create_webmocks(attrs)
 
-          put :update, params: {:id => m.id, :include => includes, singular_name => attrs}, format: :json
+          put resource_path(:update, :id => m.id, :format => 'json'), params: { include: includes, singular_name => attrs }
           assert_response :ok, "Updating #{m.class.name} with #{attrs.inspect}"
         
+          controller_model = @controller.instance_variable_get("@#{singular_name}")
           json = JSON.parse(response.body)
           includes.each do |included|
             assert json.key?(included.to_s), "#{included.inspect} not included in response"
 
-            association = assigns(singular_name).class.reflect_on_association(included)
+            association = controller_model.class.reflect_on_association(included)
             next if !association
 
             if ['belongs_to', 'has_one'].include?(association.macro.to_s)
-              view_attributes(assigns(singular_name).send(included)) do |key, value|
-                message = "Model / Attribute: #{assigns(singular_name).send(included).class.name}##{key}"
+              view_attributes(controller_model.send(included)) do |key, value|
+                message = "Model / Attribute: #{controller_model.send(included).class.name}##{key}"
                 assert_equal json[included.to_s][key.to_s], value, message
               end
             else
-              m = assigns(singular_name).send(included).first.try(:reload)
+              m = controller_model.send(included).first.try(:reload)
               m_json = if m && m.has_attribute?(:id)
                 json[included.to_s].find { |x| x['id'] == normalize_to_json(m, :id, m.id) }
               elsif m
@@ -113,14 +115,18 @@ module StandardAPI
       end
 
       test '#update.json mask' do
+        m = create_model
+
+        # This is just to instance @controller
+        get resource_path(:index, format: :json), params: { limit: 1 }
+
         # If #current_mask isn't defined by StandardAPI we don't know how to
         # test other's implementation of #current_mask. Return and don't test.
         return if @controller.method(:current_mask).owner != StandardAPI
 
-        m = create_model
         @controller.current_mask[plural_name] = { id: m.id + 1 }
         assert_raises(ActiveRecord::RecordNotFound) do
-          put :update, params: {id: m.id}, format: 'json'
+          put resource_path(:update, :id => m.id, :format => 'json')
         end
         @controller.current_mask.delete(plural_name)
       end

data/lib/standard_api/test_case.rb

@@ -1,23 +1,17 @@
 require 'active_support/test_case'
 
 require File.expand_path(File.join(__FILE__, '../test_case/calculate_tests'))
-require File.expand_path(File.join(__FILE__, '../test_case/new_tests'))
 require File.expand_path(File.join(__FILE__, '../test_case/create_tests'))
 require File.expand_path(File.join(__FILE__, '../test_case/destroy_tests'))
 require File.expand_path(File.join(__FILE__, '../test_case/index_tests'))
+require File.expand_path(File.join(__FILE__, '../test_case/new_tests'))
+require File.expand_path(File.join(__FILE__, '../test_case/schema_tests'))
 require File.expand_path(File.join(__FILE__, '../test_case/show_tests'))
 require File.expand_path(File.join(__FILE__, '../test_case/update_tests'))
 
 module StandardAPI::TestCase
       
   def self.included(klass)
-    begin
-      controller_class_name = klass.name.gsub(/Test$/, '')
-      controller_class_name.constantize 
-    rescue NameError => e
-      raise e if e.message != "uninitialized constant #{controller_class_name}"
-    end
-
     [:filters, :orders, :includes].each do |attribute|
       klass.send(:class_attribute, attribute)
     end
@@ -41,14 +35,13 @@ module StandardAPI::TestCase
       acc
     end
 
-
     klass.controller_class.action_methods.each do |action|
       if const_defined?("StandardAPI::TestCase::#{action.capitalize}Tests") && routes[klass.controller_class.controller_path][action]
         klass.include("StandardAPI::TestCase::#{action.capitalize}Tests".constantize)
       end
     end
   end
-  
+
   def supports_format(format)
     count = controller_class.view_paths.count do |path|
       !Dir.glob("#{path.instance_variable_get(:@path)}/{#{model.name.underscore},application}/**/*.#{format}*").empty?
@@ -60,18 +53,33 @@ module StandardAPI::TestCase
   def required_orders
     controller_class.new.send(:required_orders)
   end
-  
-  def controller_class
-    controller_class_name = self.class.name.gsub(/Test$/, '')
-    controller_class_name.constantize 
-  rescue NameError => e
-    raise e if e.message != "uninitialized constant #{controller_class_name}"
-  end
 
   def model
     self.class.model
   end
 
+  def resource_path(action, options={})
+    url_for({
+      controller: model.model_name.plural, action: action
+    }.merge(options))
+    # case action
+    # when :index, :create
+    #   send "#{model.model_name.plural.underscore}_path", *args
+    # when :schema, :calculate
+    #   send "#{model.model_name.plural.underscore}_#{action}_path", *args
+    # else
+    #   send "#{action}_#{model.model_name.underscore}_path", *args
+    # end
+  end
+
+  # def resoruces_path(action, *args)
+  #   send "#{model.model_name.plural.underscore}_path", *args
+  # end
+
+  def controller_class
+    self.class.controller_class
+  end
+
   def create_model(*args)
     create(model.name.underscore, *args)
   end
@@ -128,6 +136,13 @@ module StandardAPI::TestCase
       klass.instance_variable_set('@normalizers', {})
     end
 
+    def controller_class
+      controller_class_name = self.name.gsub(/Test$/, '')
+      controller_class_name.constantize 
+    rescue NameError => e
+      raise e if e.message != "uninitialized constant #{controller_class_name}"
+    end
+
     def include_filter_tests
       model.instance_variable_get('@filters').each do |filter|
         next if filter[1].is_a?(Proc) # Custom filter

data/lib/standard_api/version.rb

@@ -0,0 +1,3 @@
+module StandardAPI
+  VERSION = '5.0.0.5'
+end

data/lib/standard_api/views/application/schema.json.jbuilder

@@ -20,11 +20,15 @@ mapping = {
     'geometry' => 'ewkb'
 }
 
-model.columns.each do |column|
-  json.set! column.name, {
-    type: mapping[column.sql_type],
-    primary_key: column.name == model.primary_key,
-    null: column.null,
-    array: column.array
-  }
-end
+json.set! 'columns' do
+  model.columns.each do |column|
+    json.set! column.name, {
+      type: mapping[column.sql_type],
+      primary_key: column.name == model.primary_key,
+      null: column.null,
+      array: column.array
+    }
+  end
+end
+
+json.set! 'limit', resource_limit

data/lib/standard_api.rb

@@ -8,9 +8,7 @@ require 'active_record/filter'
 require 'active_record/sort'
 require 'active_support/core_ext/hash/indifferent_access'
 
-module StandardAPI
-end
-
+require 'standard_api/version'
 require 'standard_api/orders'
 require 'standard_api/includes'
 require 'standard_api/controller'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: standardapi
 version: !ruby/object:Gem::Version
-  version: 5.0.0.4
+  version: 5.0.0.5
 platform: ruby
 authors:
 - James Bracy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-25 00:00:00.000000000 Z
+date: 2016-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -294,13 +294,15 @@ files:
 - lib/standard_api/test_case/destroy_tests.rb
 - lib/standard_api/test_case/index_tests.rb
 - lib/standard_api/test_case/new_tests.rb
-- lib/standard_api/test_case/schema_test.rb
+- lib/standard_api/test_case/schema_tests.rb
 - lib/standard_api/test_case/show_tests.rb
 - lib/standard_api/test_case/update_tests.rb
+- lib/standard_api/version.rb
 - lib/standard_api/views/application/_record.json.jbuilder
 - lib/standard_api/views/application/index.json.jbuilder
 - lib/standard_api/views/application/new.json.jbuilder
 - lib/standard_api/views/application/schema.json.jbuilder
+- lib/standard_api/views/application/settings.json.jbuilder
 - lib/standard_api/views/application/show.json.jbuilder
 homepage: https://github.com/waratuman/standardapi
 licenses:

data/lib/standard_api/test_case/schema_test.rb

@@ -1,8 +0,0 @@
-module StandardAPI
-  module TestCase
-    module IndexTests
-      extend ActiveSupport::Testing::Declarative
-
-    end
-  end
-end