apes 1.0.0

data/lib/apes/version.rb

@@ -0,0 +1,24 @@
+#
+# This file is part of the apes gem. Copyright (C) 2016 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+# A tiny JSON API framework for Ruby on Rails.
+module Apes
+  # The current version of apes, according to semantic versioning.
+  #
+  # @see http://semver.org
+  module Version
+    # The major version.
+    MAJOR = 1
+
+    # The minor version.
+    MINOR = 0
+
+    # The patch version.
+    PATCH = 0
+
+    # The current version of apes.
+    STRING = [MAJOR, MINOR, PATCH].compact.join(".")
+  end
+end

data/spec/apes/concerns/errors_spec.rb

@@ -0,0 +1,141 @@
+require "spec_helper"
+
+describe Apes::Concerns::Errors do
+  class ErrorHandlingMockContainer
+    include Apes::Concerns::Errors
+
+    def request_valid_content_type
+      "FOO"
+    end
+  end
+
+  class ErrorHandlingMockModel
+    include ActiveModel::Validations
+
+    attr_reader :field, :other_field
+    validates :field, presence: true
+    validates :other_field, presence: true
+
+    def self.i18n_scope
+      :activerecord
+    end
+  end
+
+  subject { ErrorHandlingMockContainer.new }
+
+  describe "fail_request!" do
+    it "should raise the right exception" do
+      expect { subject.fail_request!(1, 2) }.to raise_error(Apes::Errors::BaseError)
+    end
+  end
+
+  describe "error_handle_exception" do
+    it "should call the right handler" do
+      expect(subject).to receive(:error_handle_bad_request)
+      subject.error_handle_exception(::Apes::Errors::BadRequestError.new)
+
+      expect(subject).to receive(:error_handle_invalid_data)
+      subject.error_handle_exception(::Apes::Errors::InvalidDataError.new)
+
+      expect(subject).to receive(:error_handle_others)
+      subject.error_handle_exception(RuntimeError.new)
+    end
+  end
+
+  describe "error_handle_general" do
+    it "should render the right template" do
+      expect(subject).to receive(:render_error).with(401, "FOO")
+      subject.error_handle_general(::Apes::Errors::BaseError.new({status: 401, error: "FOO"}))
+    end
+  end
+
+  describe "error_handle_others" do
+    it "should render the right template and store the useful information" do
+      allow(Apes::RuntimeConfiguration).to receive(:rails_root).and_return("/abc")
+      allow(Apes::RuntimeConfiguration).to receive(:gems_root).and_return("/cde")
+
+      err = RuntimeError.new
+      allow(err).to receive(:backtrace).and_return(["FOO", Apes::RuntimeConfiguration.rails_root + "/foo", Apes::RuntimeConfiguration.gems_root + "/foo"])
+
+      expect(subject).to receive(:render).with("errors/500", status: :internal_server_error)
+      subject.error_handle_others(err)
+      expect(subject.instance_variable_get(:@exception)).to be(err)
+      expect(subject.instance_variable_get(:@backtrace)).to eq(["FOO", "$RAILS/foo", "$GEMS/foo"])
+    end
+  end
+
+  describe "error_handle_debug" do
+    it "should render the right template with the right data" do
+      err = Lazier::Exceptions::Debug.new({a: 1, b: 2}.to_json)
+      expect(subject).to receive(:render).with("errors/400", status: 418, locals: {debug: {"a" => 1, "b" => 2}})
+      subject.error_handle_debug(err)
+    end
+  end
+
+  describe "error_handle_fordidden" do
+    it "should render the right template with the right message" do
+      expect(subject).to receive(:render).with("errors/403", status: :forbidden).exactly(2)
+
+      subject.error_handle_fordidden(RuntimeError.new("FOO"))
+      expect(subject.instance_variable_get(:@authentication_error)).to eq({error: "FOO"})
+
+      subject.error_handle_fordidden(RuntimeError.new(""))
+      expect(subject.instance_variable_get(:@authentication_error)).to eq({error: "You don't have access to this resource."})
+    end
+  end
+
+  describe "error_handle_not_found" do
+    it "should render the right template" do
+      expect(subject).to receive(:render).with("errors/404", status: :not_found)
+      subject.error_handle_not_found
+    end
+  end
+
+  describe "error_handle_bad_request" do
+    it "should render the right template with the right reason" do
+      expect(subject).to receive(:render).with("errors/400", status: :bad_request)
+      subject.error_handle_bad_request
+      expect(subject.instance_variable_get(:@reason)).to eq("Invalid Content-Type specified. Please use \"FOO\" when performing write operations.")
+    end
+  end
+
+  describe "error_handle_missing_data" do
+    it "should render the right template with the right reason" do
+      expect(subject).to receive(:render).with("errors/400", status: :bad_request)
+      subject.error_handle_missing_data
+      expect(subject.instance_variable_get(:@reason)).to eq("Missing data.")
+    end
+  end
+
+  describe "error_handle_invalid_data" do
+    it "should render the right template with the right reason" do
+      expect(subject).to receive(:render).with("errors/400", status: :bad_request)
+      subject.error_handle_invalid_data
+      expect(subject.instance_variable_get(:@reason)).to eq("Invalid data provided.")
+    end
+  end
+
+  describe "error_handle_unknown_attribute" do
+    it "should render the right template with the right errors" do
+      object = ErrorHandlingMockModel.new
+
+      expect(subject).to receive(:render).with("errors/422", status: :unprocessable_entity).exactly(2)
+      subject.error_handle_unknown_attribute(ActionController::UnpermittedParameters.new(["A", "B"]))
+      expect(subject.instance_variable_get(:@errors)).to eq(["A", "B"])
+
+      subject.error_handle_unknown_attribute(ActiveRecord::UnknownAttributeError.new(object, "C"))
+      expect(subject.instance_variable_get(:@errors)).to eq("C")
+    end
+  end
+
+  describe "error_handle_validation" do
+    it "should render the right template with the right errors" do
+      object = ErrorHandlingMockModel.new
+      object.validate
+
+      expect(subject).to receive(:render).with("errors/422", status: :unprocessable_entity)
+      subject.error_handle_validation(ActiveRecord::RecordInvalid.new(object))
+      expect(subject.instance_variable_get(:@errors)).to eq({field: ["can't be blank"], other_field: ["can't be blank"]})
+    end
+  end
+end

data/spec/apes/concerns/pagination_spec.rb

@@ -0,0 +1,114 @@
+require "spec_helper"
+
+describe Apes::Concerns::Pagination do
+  class PaginationHandlingMockContainer
+    include Apes::Concerns::Pagination
+
+    attr_reader :cursor
+
+    def initialize(params = {}, field = :page, count_field = :count)
+      @cursor = Apes::PaginationCursor.new(params, field, count_field)
+    end
+
+    def request
+      OpenStruct.new(params: {a: 1, b: 2})
+    end
+
+    def url_for(params)
+      params
+    end
+  end
+
+  subject { PaginationHandlingMockContainer.new }
+
+  describe "#paginate" do
+    context "when NOT using the offset" do
+      it "should apply the query" do
+        collection = []
+        cursor = JWT.encode({aud: "pagination", sub: {value: "2001-02-03T04:05:06.789+0700", size: 34, direction: "next"}}, Apes::RuntimeConfiguration.jwt_token, "HS256")
+        subject = PaginationHandlingMockContainer.new({page: cursor})
+
+        expect(collection).to receive(:columns_hash).and_return({"created_at" => OpenStruct.new(type: "datetime")})
+        expect(collection).to receive(:where).with("created_at > ?", DateTime.civil(2001, 2, 3, 4, 5, 6.789, "+7")).and_return(collection)
+        expect(collection).to receive(:limit).with(34).and_return(collection)
+        expect(collection).to receive(:order).with("created_at ASC").and_return(collection)
+
+        expect(subject.paginate(collection, sort_field: :created_at, sort_order: :asc)).to eq(collection)
+      end
+    end
+
+    context "when using the offset" do
+      it "should apply the query" do
+        collection = []
+        cursor = JWT.encode({aud: "pagination", sub: {value: 12, size: 56, use_offset: true, direction: "next"}}, Apes::RuntimeConfiguration.jwt_token, "HS256")
+        subject = PaginationHandlingMockContainer.new({page: cursor})
+
+        expect(collection).to receive(:offset).with(12).and_return(collection)
+        expect(collection).to receive(:limit).with(56).and_return(collection)
+        expect(collection).to receive(:order).with("id ASC").and_return(collection)
+
+        expect(subject.paginate(collection, sort_field: :id, sort_order: :asc)).to eq(collection)
+      end
+    end
+
+    context "when NOT going next" do
+      it "should reverse results" do
+        collection = []
+        cursor = JWT.encode({aud: "pagination", sub: {value: 12, size: 56, use_offset: true, direction: "prev"}}, Apes::RuntimeConfiguration.jwt_token, "HS256")
+        subject = PaginationHandlingMockContainer.new({page: cursor})
+
+        expect(collection).to receive(:offset).and_return(collection)
+        expect(collection).to receive(:limit).and_return(collection)
+        expect(collection).to receive(:order).and_return(collection)
+        expect(collection).to receive(:reverse_order).and_return(collection)
+        expect(collection).to receive(:reverse).and_return(collection)
+        expect(subject.paginate(collection, sort_field: :id, sort_order: :asc)).to eq(collection)
+      end
+    end
+  end
+
+  describe "#pagination_field" do
+    it "should return the right field" do
+      expect(subject.pagination_field).to eq(:handle)
+
+      subject.instance_variable_set(:@pagination_field, :foo)
+      expect(subject.pagination_field).to eq(:foo)
+    end
+  end
+
+  describe "#pagination_skip?" do
+    it "should return the right value" do
+      expect(subject.pagination_skip?).to be_nil
+
+      subject.instance_variable_set(:@skip_pagination, "FOO")
+      expect(subject.pagination_skip?).to eq("FOO")
+    end
+  end
+
+  describe "#pagination_supported?" do
+    it "check whether pagination is supported" do
+      expect(subject.pagination_supported?).to be_falsey
+
+      subject.instance_variable_set(:@objects, OpenStruct.new(first: true))
+      expect(subject.pagination_supported?).to be_falsey
+
+      subject.instance_variable_set(:@objects, [])
+      expect(subject.pagination_supported?).to be_truthy
+    end
+  end
+
+  describe "#pagination_url" do
+    it "should return null when not supported" do
+      expect(subject.pagination_url("next")).to be_nil
+    end
+
+    it "should return the right URL when supported" do
+      subject.instance_variable_set(:@objects, ["FOO"])
+
+      allow(subject.cursor).to receive(:might_exist?).with("prev", ["FOO"]).and_return(true)
+      allow(subject.cursor).to receive(:save).with(["FOO"], "prev", field: :handle).and_return("URL")
+
+      expect(subject.pagination_url("prev")).to eq({a: 1, b: 2, only_path: false, page: "URL"})
+    end
+  end
+end

data/spec/apes/concerns/request_spec.rb

@@ -0,0 +1,244 @@
+require "spec_helper"
+
+describe Apes::Concerns::Request do
+  class RequestHandlingMockContainer
+    include Apes::Concerns::Request
+    
+    attr_reader :request, :response, :params, :headers
+    
+    def initialize(request = nil, params = nil)
+      @request = OpenStruct.new(request || {format: nil, url: "", body: "FOO"})
+      @response ||= OpenStruct.new({content_type: :html})
+      @params = params || HashWithIndifferentAccess.new
+      @headers = HashWithIndifferentAccess.new
+    end
+    
+    def fail_request!(status, error)
+      raise(Apes::Errors::BaseError, {status: status, error: error})
+    end
+  end
+  
+  FirstMockModel = Struct.new(:id)
+  
+  class SecondMockModel
+  end
+  
+  class MockModel
+    include ActiveModel::Model
+    include Apes::Model
+    
+    ATTRIBUTES = [:id, :other, :created_at, :first_mock_model]
+    RELATIONSHIPS = {first_mock_model: nil, second: SecondMockModel}
+    
+    def self.column_types
+      {"id" =>  OpenStruct.new(type: :string), "other" => OpenStruct.new(type: :boolean), "created_at" => OpenStruct.new(type: :datetime)}
+    end
+  end
+
+  before(:each) do
+    allow(Apes::RuntimeConfiguration).to receive(:timestamp_formats).and_return({full: "%FT%T.%L%z"})
+    allow(Apes::RuntimeConfiguration).to receive(:development?).and_return(true)
+  end
+
+  subject { RequestHandlingMockContainer.new }
+  
+  describe "#request_handle_cors" do
+    it "should set the right headers" do
+      allow(subject).to receive(:request_source_host).and_return("FOO")
+      
+      subject.request_handle_cors
+      expect(subject.headers).to eq({
+        "Access-Control-Allow-Headers" => "Content-Type, X-User-Email, X-User-Token",
+        "Access-Control-Allow-Methods" => "POST, GET, PUT, DELETE, OPTIONS",
+        "Access-Control-Allow-Origin" => "http://FOO:4200",
+        "Access-Control-Max-Age" => "31557600"
+      })
+    end
+  end
+  
+  describe "#request_validate" do
+    it "should override the request format and the response content type, then prepare the data" do
+      subject.request_validate
+      
+      expect(subject.request.format).to eq(:json)
+      expect(subject.response.content_type).to eq("application/vnd.api+json")
+      expect(subject.params[:data]).to be_a(HashWithIndifferentAccess)
+    end
+    
+    it "should complain when the provided content_type is wrong" do
+      allow(subject.request).to receive(:post?).and_return(true)
+      allow(subject.request).to receive(:content_type).and_return("FOO")
+      
+      expect { subject.request_validate }.to raise_error(Apes::Errors::BadRequestError)
+    end
+    
+    it "should complain when the data is missing" do
+      allow(subject.request).to receive(:post?).and_return(true)
+      allow(subject.request).to receive(:content_type).and_return(Apes::Concerns::Request::CONTENT_TYPE)
+      
+      expect { subject.request_validate }.to raise_error(Apes::Errors::MissingDataError)
+    end
+    
+    it "should complain when the data is not a valid JSON" do
+      subject.request.body = OpenStruct.new(read: "FOO")
+      allow(subject.request).to receive(:post?).and_return(true)
+      allow(subject.request).to receive(:content_type).and_return(Apes::Concerns::Request::CONTENT_TYPE)
+      
+      expect { subject.request_validate }.to raise_error(Apes::Errors::InvalidDataError)
+    end
+    
+    it "should complain when the data is missing in the data attribute for JSON API requests" do
+      subject.request.body = OpenStruct.new(read: {a: 1}.to_json)
+      allow(subject.request).to receive(:post?).and_return(true)
+      allow(subject.request).to receive(:content_type).and_return(Apes::Concerns::Request::CONTENT_TYPE)
+      
+      expect { subject.request_validate }.to raise_error(Apes::Errors::MissingDataError)
+    end
+  end
+  
+  describe "#request_source_host" do
+    it "should return the right host" do
+      subject.request.url = "http://abc.google.it:1234"
+      expect(subject.request_source_host).to eq("abc.google.it")
+    end
+  end
+  
+  describe "#request_valid_content_type" do
+    it "should return the right type" do
+      expect(subject.request_valid_content_type).to eq("application/vnd.api+json")
+    end
+  end
+  
+  describe "#request_extract_model" do
+    before(:each) do
+      allow(subject.request).to receive(:post?).and_return(true)
+      allow(subject.request).to receive(:content_type).and_return(Apes::Concerns::Request::CONTENT_TYPE)
+      ActionController::Parameters.action_on_unpermitted_parameters = :raise
+    end
+    
+    it "should complain if the type is missing in the data" do
+      subject.request.body = OpenStruct.new(read: {data: {foo: 1, body: 1}}.to_json)
+      subject.request_validate
+      
+      expect(subject).to receive(:fail_request!).with(:bad_request, "No type provided when type \"mock_model\" was expected.").and_raise(RuntimeError)
+      expect { subject.request_extract_model(MockModel.new) }.to raise_error(RuntimeError)
+    end
+    
+    it "should complain if the type is wrong in the data" do
+      subject.request.body = OpenStruct.new(read: {data: {type: "foo", foo: 1, body: 1}}.to_json)
+      subject.request_validate
+      
+      expect(subject).to receive(:fail_request!).with(:bad_request, "Invalid type \"foo\" provided when type \"mock_model\" was expected.").and_raise(RuntimeError)
+      expect { subject.request_extract_model(MockModel.new) }.to raise_error(RuntimeError)
+    end
+    
+    it "should complain if the data is not inside the attributes field" do
+      subject.request.body = OpenStruct.new(read: {data: {type: "mock_model", foo: 1, body: 1}}.to_json)
+      subject.request_validate
+      
+      expect(subject).to receive(:fail_request!).with(:bad_request, "Missing attributes in the \"attributes\" field.").and_raise(RuntimeError)
+      expect { subject.request_extract_model(MockModel.new) }.to raise_error(RuntimeError)
+    end
+    
+    it "should complain if any unknown attribute is present for the mock_model" do
+      subject.request.body = OpenStruct.new(read: {data: {type: "mock_model", attributes: {foo: 1, other: 1}}}.to_json)
+      subject.request_validate
+      
+      expect { subject.request_extract_model(MockModel.new) }.to raise_error(ActionController::UnpermittedParameters) do |error|
+        expect(error.params).to eq(["attributes.foo"])
+      end
+    end
+    
+    it "should allowed hash attributes" do
+      subject.request.body = OpenStruct.new(read: {data: {type: "mock_model", attributes: {foo: 1, other: {a: 1}}}}.to_json)
+      subject.request_validate
+      
+      expect { subject.request_extract_model(MockModel.new) }.to raise_error(ActionController::UnpermittedParameters) do |error|
+        expect(error.params).to eq(["attributes.foo"])
+      end
+    end
+    
+    it "should return attributes for the mock_model" do
+      subject.request.body = OpenStruct.new(read: {data: {type: "mock_model", attributes: {id: "1", other: 1}}}.to_json)
+      subject.request_validate
+      
+      expect(subject.request_extract_model(MockModel.new)).to eq({id: "1", other: 1}.with_indifferent_access)
+    end
+    
+    it "should return relationships for the model" do
+      first = FirstMockModel.new(1)
+      allow(FirstMockModel).to receive(:find_with_any).and_return(first)
+      subject.request.body = OpenStruct.new(read: {data: {type: "mock_model", attributes: {id: 1}, relationships: {first_mock_model: {data: {type: "first_mock_model", id: first.id}}}}}.to_json)
+      subject.request_validate
+      
+      expect(subject.request_extract_model(MockModel.new)).to eq({id: 1, first_mock_model: first}.with_indifferent_access)
+    end
+    
+    it "should move inline references to the relationship objects" do
+      first = FirstMockModel.new(1)
+      allow(FirstMockModel).to receive(:find_with_any).and_return(first)
+      subject.request.body = OpenStruct.new(read: {data: {type: "mock_model", attributes: {id: 1, first_mock_model: first.id}}}.to_json)
+      subject.request_validate
+      
+      extracted = subject.request_extract_model(MockModel.new)
+      expect(extracted.keys.map(&:to_sym)).to eq([:id, :first_mock_model])
+      expect(extracted[:first_mock_model].id).to eq(first.id)
+    end
+    
+    it "should reject unallowed relationships" do
+      subject.request.body = OpenStruct.new(read: {data: {type: "mock_model", attributes: {id: 1}, relationships: {another: {}}}}.to_json)
+      subject.request_validate
+      
+      target = MockModel.new
+      expect { subject.request_extract_model(target) }.to raise_error(ActionController::UnpermittedParameters) do |error|
+        expect(error.params).to eq(["relationships.another"])
+      end
+    end
+    
+    it "should reject malformed relationships" do
+      first = FirstMockModel.new(1)
+      
+      target = MockModel.new
+      subject.request.body = OpenStruct.new(read: {data: {type: "mock_model", attributes: {id: 1}, relationships: {first_mock_model: {data: {id: first.id}}}}}.to_json)
+      subject.request_validate
+      subject.request_extract_model(target)
+      expect(target.additional_errors.to_hash).to eq({first_mock_model: ["Relationship does not contain the \"data.type\" attribute"]})
+      
+      target = MockModel.new
+      subject.request.body = OpenStruct.new(read: {data: {type: "mock_model", attributes: {id: 1}, relationships: {first_mock_model: {data: {type: "first_mock_model"}}}}}.to_json)
+      subject.request_validate
+      subject.request_extract_model(target)
+      expect(target.additional_errors.to_hash).to eq({first_mock_model: ["Relationship does not contain the \"data.id\" attribute"]})
+      
+      target = MockModel.new
+      subject.request.body = OpenStruct.new(read: {data: {type: "mock_model", attributes: {id: 1}, relationships: {first_mock_model: {data: {type: "foo", id: 1}}}}}.to_json)
+      subject.request_validate
+      subject.request_extract_model(target)
+      expect(target.additional_errors.to_hash).to eq({first_mock_model: ["Invalid relationship type \"foo\" provided for when type \"first_mock_model\" was expected."]})
+    end
+    
+    it "should reject invalid relationships" do
+      allow(SecondMockModel).to receive(:find_with_any).and_return(false)
+      target = MockModel.new
+      subject.request.body = OpenStruct.new(read: {data: {type: "mock_model", attributes: {id: 1}, relationships: {second: {data: {type: "second_mock_model", id: -1}}}}}.to_json)
+      subject.request_validate
+      subject.request_extract_model(target)
+      expect(target.additional_errors.to_hash).to eq({second: ["Refers to a non existing \"second_mock_model\" resource."]})
+    end
+  end
+  
+  describe "#request_cast_attributes" do
+    it "should correctly cast attributes for a mock_model" do
+      attributes = {id: 3, other: "YES", created_at: "2001-02-03T04:05:06.789+0700"}.with_indifferent_access
+      casted_attributes = {id: 3, other: true, created_at: DateTime.civil(2001, 2, 3, 4, 5, 6.789, "+7")}.with_indifferent_access
+      expect(subject.request_cast_attributes(MockModel.new, attributes)).to eq(casted_attributes)
+    end
+    
+    it "should add casting errors to the mock_model validation errors" do
+      attributes = {id: 3, other: "yes", created_at: "NO"}.with_indifferent_access
+      object = MockModel.new
+      subject.request_cast_attributes(object, attributes)
+      expect(object.additional_errors.to_hash).to eq(created_at: ["Invalid timestamp \"NO\"."])
+    end
+  end
+end