rice_cooker 0.1.1

data/spec/filter/filter_spec.rb

@@ -0,0 +1,264 @@
+require 'pry'
+require 'rice_cooker'
+require 'active_record'
+require 'spec_helper'
+
+RSpec.describe RiceCooker::Filter do
+  include RiceCooker::Helpers
+
+  # class User < ActiveRecord::Base; end
+
+  before do
+    @collection_class = User
+    @allowed_params = filterable_fields_for(@collection_class)
+    @collection = @collection_class.all
+
+    @test_filter = {
+      with_the_letter: { proc: -> (value) { where('first_name ILIKE ?', value.map { |e| "%#{e}%" }) } },
+      without_the_letter: { proc: -> (value) { where.not('first_name ILIKE ?', value.map { |e| "%#{e}%" }) } }
+    }
+
+    @proc = -> (value) { value }
+    @all = -> (_value) { [1, 2, 3] }
+  end
+
+  describe 'Filter params must be okay' do
+    it 'Null filtering' do
+      # Default null filtering
+      filtering_params = parse_filtering_param('', @allowed_params)
+      expect(filtering_params).to be_eql({})
+    end
+
+    it 'Default filtering' do
+      params = {
+        login: 'aaubin'
+      }
+
+      filtering_params = parse_filtering_param(params, @allowed_params)
+      expect(filtering_params).to be_eql(login: ['aaubin'])
+    end
+
+    it 'Double filtering' do
+      params = {
+        login: 'aaubin,qbollach'
+      }
+
+      filtering_params = parse_filtering_param(params, @allowed_params)
+      expect(filtering_params).to be_eql(login: %w(aaubin qbollach))
+    end
+
+    it 'Multiple filtering' do
+      params = {
+        login: 'aaubin,qbollach,andre',
+        id: '74,75,76'
+      }
+
+      filtering_params = parse_filtering_param(params, @allowed_params)
+      expect(filtering_params).to be_eql(login: %w(aaubin qbollach andre),
+                                         id: %w(74 75 76))
+    end
+
+    it 'invalid args' do
+      # invalid args
+
+      params = {
+        wtf: 'aaubin,qbollach,andre',
+        id: '74,75,76'
+      }
+
+      expect { parse_filtering_param(params, @allowed_params) }.to raise_error(RiceCooker::InvalidFilterException)
+    end
+  end
+
+  describe 'Must apply filter to given collection' do
+    it 'Default null filtering' do
+      filtered_collection = apply_filter_to_collection(@collection, {})
+      # puts filtered_collection.to_sql
+      expect(filtered_collection.to_sql).to match(/^((?!WHERE).)*$/)
+    end
+
+    it 'Default filtering' do
+      filtered_collection = apply_filter_to_collection(@collection, login: ['aaubin'])
+      # puts filtered_collection.to_sql
+      expect(filtered_collection.to_sql).to match(/WHERE/)
+      expect(filtered_collection.to_sql).to match(/"login" = 'aaubin'/)
+    end
+
+    it 'Double filtering' do
+      # Desc filtering
+      filtered_collection = apply_filter_to_collection(@collection, login: %w(aaubin qbollach))
+      # puts filtered_collection.to_sql
+      expect(filtered_collection.to_sql).to match(/WHERE/)
+      expect(filtered_collection.to_sql).to match(/"login" IN \('aaubin', 'qbollach'\)/)
+    end
+
+    it 'Multiple filtering' do
+      # Desc filtering
+      filtered_collection = apply_filter_to_collection(@collection, login: %w(aaubin qbollach andre),
+                                                                    id: %w(74 75 76))
+      # puts filtered_collection.to_sql
+      expect(filtered_collection.to_sql).to match(/WHERE/)
+      expect(filtered_collection.to_sql).to match(/"login" IN \('aaubin', 'qbollach', 'andre'\)/)
+      expect(filtered_collection.to_sql).to match(/AND/)
+    end
+  end
+
+  describe 'Must apply custom filters to given collection' do
+    it 'Default null filtering' do
+      filtered_collection = apply_filter_to_collection(@collection, {}, @test_filter)
+      # puts filtered_collection.to_sql
+      expect(filtered_collection.to_sql).to match(/^((?!WHERE).)*$/)
+    end
+
+    it 'Default filtering' do
+      filtered_collection = apply_filter_to_collection(@collection, { with_the_letter: ['a'] }, @test_filter)
+      # puts filtered_collection.to_sql
+      expect(filtered_collection.to_sql).to match(/WHERE/)
+      expect(filtered_collection.to_sql).to match(/ILIKE/)
+    end
+
+    it 'Double filtering' do
+      # Desc filtering
+      filtered_collection = apply_filter_to_collection(@collection, { with_the_letter: ['a'], without_the_letter: ['l'] }, @test_filter)
+      # puts filtered_collection.to_sql
+      expect(filtered_collection.to_sql).to match(/WHERE/)
+      expect(filtered_collection.to_sql).to match(/first_name ILIKE '%a%'/)
+      expect(filtered_collection.to_sql).to match(/NOT \(first_name ILIKE '%l%'\)/)
+    end
+
+    it 'Multiple filtering' do
+      # Desc filtering
+      filtered_collection = apply_filter_to_collection(@collection, login: %w(aaubin qbollach andre),
+                                                                    id: %w(74 75 76))
+      # puts filtered_collection.to_sql
+      expect(filtered_collection.to_sql).to match(/WHERE/)
+      expect(filtered_collection.to_sql).to match(/"login" IN \('aaubin', 'qbollach', 'andre'\)/)
+      expect(filtered_collection.to_sql).to match(/AND/)
+    end
+
+    it 'invalid args' do
+      # invalid args
+      expect do
+        apply_filter_to_collection(
+          @collection,
+          { sorted: %w(true baguette) },
+          format_additional_param(sorted: [-> (v) { v }, %w(true false maybe)])
+        )
+      end.to raise_error(RiceCooker::InvalidFilterValueException)
+    end
+  end
+
+  describe 'Additional params must be correctly formated' do
+    it 'No additional params' do
+      formated = format_additional_param({})
+      expect(formated).to be_eql({})
+    end
+
+    it 'Already correctly formatted additional params' do
+      p = { filter: {
+        proc: @proc,
+        all: [1, 2, 3],
+        description: 'A good filter'
+      } }
+      formated = format_additional_param(p)
+      expect(formated).to be_eql(p)
+    end
+
+    it 'Missing description additional params' do
+      p = { filter: {
+        proc: @proc,
+        all: [1, 2, 3]
+      } }
+      expected = { filter: {
+        proc: @proc,
+        all: [1, 2, 3],
+        description: ''
+      } }
+      formated = format_additional_param(p)
+      expect(formated).to be_eql(expected)
+    end
+
+    it 'Only proc additional params' do
+      p = { filter: @proc }
+      expected = { filter: {
+        proc: @proc,
+        all: [],
+        description: ''
+      } }
+      formated = format_additional_param(p)
+      expect(formated).to be_eql(expected)
+    end
+
+    it 'Array with proc and all additional params' do
+      p = { filter: [@proc, @all] }
+      expected = { filter: {
+        proc: @proc,
+        all: @all,
+        description: ''
+      } }
+      formated = format_additional_param(p)
+      expect(formated).to be_eql(expected)
+    end
+
+    it 'Multiple, std + Array with proc and all additional params' do
+      p = {
+        tata: @proc,
+        toto: { proc: @proc, all: [1, 2] },
+        filter: [@proc, @all],
+        tutu: { proc: @proc, description: 'Buuuuh' }
+      }
+      expected = {
+        tata: {
+          proc: @proc,
+          all: [],
+          description: ''
+        },
+        toto: {
+          proc: @proc,
+          all: [1, 2],
+          description: ''
+        },
+        filter: {
+          proc: @proc,
+          all: @all,
+          description: ''
+        },
+        tutu: {
+          proc: @proc,
+          all: [],
+          description: 'Buuuuh'
+        }
+      }
+      formated = format_additional_param(p)
+      expect(formated).to be_eql(expected)
+    end
+  end
+end
+
+RSpec.describe UsersController, type: :controller do
+  include RiceCooker::Helpers
+
+  before { request.host = 'example.org' }
+
+  describe 'GET #index' do
+    it 'without filter parameter' do
+      process :index, method: :get, params: { filter: '', format: :json }
+      expect(response.body).to eq(User.all.order(id: :desc).to_json)
+    end
+
+    it 'with simple filter parameter' do
+      process :index, method: :get, params: { filter: { login: 'aaubin' }, format: :json }
+      expect(response.body).to eq(User.where(login: 'aaubin').order(id: :desc).to_json)
+    end
+
+    it 'with double filter parameter' do
+      process :index, method: :get, params: { filter: { login: 'aaubin,qbollach' }, format: :json }
+      expect(response.body).to eq(User.where(login: %w(aaubin qbollach)).order(id: :desc).to_json)
+    end
+
+    it 'with double and multiple filter parameter' do
+      process :index, method: :get, params: { filter: { login: 'aaubin,qbollach', email: 'tata' }, format: :json }
+      expect(response.body).to eq(User.where(login: %w(aaubin qbollach), email: 'tata').order(id: :desc).to_json)
+    end
+  end
+end

data/spec/mocks/config.rb

@@ -0,0 +1,2 @@
+ActiveRecord::Base.configurations = { 'test' => { adapter: 'sqlite3', database: ':memory:' } }
+ActiveRecord::Base.establish_connection :test

data/spec/mocks/controllers/users_controller.rb

@@ -0,0 +1,58 @@
+require 'action_controller'
+require 'ostruct'
+require 'has_scope'
+
+module Rails
+  def self.application
+    @application ||= begin
+      routes = ActionDispatch::Routing::RouteSet.new
+      OpenStruct.new(routes: routes, env_config: {})
+    end
+  end
+end
+
+module ControllerExampleGroup
+  def self.included(base)
+    base.extend ClassMethods
+    base.send(:include, ActionController::TestCase::Behavior)
+
+    base.prepend_before do
+      @routes = Rails.application.routes
+      @controller = described_class.new
+    end
+  end
+
+  module ClassMethods
+    def setup(*methods)
+      methods.each do |method|
+        if method.to_s =~ /^setup_(fixtures|controller_request_and_response)$/
+          prepend_before { send method }
+        else
+          before         { send method }
+        end
+      end
+    end
+
+    def teardown(*methods)
+      methods.each { |method| after { send method } }
+    end
+  end
+end
+
+Rails.application.routes.draw do
+  resources :users, only: [:index]
+end
+
+class UsersController < ActionController::Base
+  include Rails.application.routes.url_helpers
+
+  sorted
+  filtered
+  ranged
+
+  def index
+    @users = apply_scopes(User).all
+    # p @users.to_sql
+    render json: @users
+  end
+end

data/spec/mocks/mocks.rb

@@ -0,0 +1,4 @@
+
+require File.join(File.dirname(__FILE__), *%w(config))
+require File.join(File.dirname(__FILE__), *%w(models user))
+require File.join(File.dirname(__FILE__), *%w(controllers users_controller))

data/spec/mocks/models/user.rb

@@ -0,0 +1,31 @@
+class User < ActiveRecord::Base
+  has_many :comments
+
+  def self.rangeable_fields
+    [:id, :login, :email]
+  end
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :user
+end
+
+# migrations
+class CreateAllTables < ActiveRecord::Migration
+  def self.up
+    create_table(:users) { |t| t.string :login; t.string :email; t.timestamps }
+    create_table(:comments) { |t| t.integer :user_id; t.string :content; t.timestamps }
+  end
+end
+
+ActiveRecord::Migration.verbose = true
+CreateAllTables.up
+
+[
+  { login: 'andre', email: 'tata' },
+  { login: 'mathieu', email: 'toto' },
+  { login: 'bobol', email: 'titi' },
+  { login: 'fred', email: 'gratti' },
+  { login: 'jeanne', email: 'zapata' },
+  { login: 'angie', email: 'tutu' }
+].each { |u| User.create!(u) }

data/spec/range/range_spec.rb

@@ -0,0 +1,265 @@
+require 'rice_cooker'
+require 'active_record'
+require 'spec_helper'
+
+RSpec.describe RiceCooker::Range do
+  include RiceCooker::Helpers
+
+  before do
+    @collection_class = User
+    @allowed_params = rangeable_fields_for(@collection_class)
+    @collection = @collection_class.all
+
+    @test_range = {
+      between_the_letter: { proc: -> (start_field, end_field) { where('first_name BETWEEN ? AND ?', start_field, end_field) } },
+      not_between_the_letter: { proc: -> (start_field, end_field) { where('first_name NOT BETWEEN ? AND ?', start_field, end_field) } }
+    }
+
+    @proc = -> (value) { value }
+    @all = -> (_value) { [1, 2, 3] }
+  end
+
+  describe 'Range params must be okay' do
+    it 'Null ranged' do
+      # Default null ranged
+      ranged_params = parse_ranged_param('', @allowed_params)
+      expect(ranged_params).to be_eql({})
+    end
+
+    it 'Default ranged' do
+      params = {
+        id: '1,5'
+      }
+      ranged_params = parse_ranged_param(params, @allowed_params)
+      expect(ranged_params).to be_eql(id: %w(1 5))
+    end
+
+    it 'Multiple ranged' do
+      params = {
+        login: 'aaubin,bobol',
+        id: '4,5'
+      }
+      ranged_params = parse_ranged_param(params, @allowed_params)
+      expect(ranged_params).to be_eql(login: %w(aaubin bobol),
+                                      id: %w(4 5))
+    end
+
+    it 'too many args' do
+      # invalid args
+
+      params = {
+        wtf: 'aaubin,qbollach,andre',
+        id: '74,75,76'
+      }
+
+      expect { parse_ranged_param(params, @allowed_params) }.to raise_error(RiceCooker::InvalidRangeException)
+    end
+
+    it 'too few args' do
+      # invalid args
+
+      params = {
+        wtf: 'aaubin',
+        id: '74'
+      }
+
+      expect { parse_ranged_param(params, @allowed_params) }.to raise_error(RiceCooker::InvalidRangeException)
+    end
+  end
+
+  describe 'Must apply range to given collection' do
+    it 'Default null ranged' do
+      ranged_collection = apply_range_to_collection(@collection, {})
+      expect(ranged_collection.to_sql).to match(/^((?!WHERE).)*$/)
+    end
+
+    it 'Default ranged' do
+      ranged_collection = apply_range_to_collection(@collection, login: %w(aaubin qbollach))
+      expect(ranged_collection.to_sql).to match(/BETWEEN/)
+      expect(ranged_collection.to_sql).to match(/'aaubin'/)
+    end
+
+    it 'Double ranged' do
+      # Desc ranged
+      ranged_collection = apply_range_to_collection(@collection, login: %w(aaubin qbollach), id: [1, 2])
+      expect(ranged_collection.to_sql).to match(/BETWEEN/)
+      expect(ranged_collection.to_sql).to match(/'aaubin'/)
+    end
+
+    it 'Invalid ranged' do
+      # Desc ranged
+      expect do
+        apply_range_to_collection(@collection, login: %w(aaubin qbollach andre),
+                                                                   id: ['74'])
+      end.to raise_error(RiceCooker::InvalidRangeValueException)
+    end
+  end
+
+  describe 'Must apply custom ranges to given collection' do
+
+    it 'Default null ranged' do
+      ranged_collection = apply_range_to_collection(@collection, {}, @test_range)
+      expect(ranged_collection.to_sql).to match(/^((?!WHERE).)*$/)
+    end
+
+    it 'Default ranged' do
+      ranged_collection = apply_range_to_collection(@collection, {between_the_letter: ['a', 'b']}, @test_range)
+      expect(ranged_collection.to_sql).to match(/WHERE/)
+      expect(ranged_collection.to_sql).to match(/BETWEEN/)
+    end
+
+    it 'Double ranged' do
+      # Desc ranged
+      ranged_collection = apply_range_to_collection(@collection, {
+        between_the_letter: ['a', 'b'],
+        not_between_the_letter: ['x', 'z']
+      }, @test_range)
+      expect(ranged_collection.to_sql).to match(/WHERE/)
+      expect(ranged_collection.to_sql).to match(/first_name BETWEEN 'a' AND 'b'/)
+      expect(ranged_collection.to_sql).to match(/AND \(first_name NOT BETWEEN 'x' AND 'z'\)/)
+    end
+
+    it 'Multiple ranged' do
+      # Desc ranged
+      ranged_collection = apply_range_to_collection(@collection, {
+        login: ['aaubin', 'qbollach'],
+        id: ['74', '76']
+      })
+      expect(ranged_collection.to_sql).to match(/WHERE/)
+      expect(ranged_collection.to_sql).to match(/BETWEEN 'aaubin' AND 'qbollach'/)
+      expect(ranged_collection.to_sql).to match(/\) AND \(/)
+      expect(ranged_collection.to_sql).to match(/BETWEEN 74 AND 76/)
+    end
+
+    it 'invalid args' do
+      # invalid args
+      expect do
+        apply_range_to_collection(
+          @collection,
+          {sorted: ['true', 'baguette']},
+          format_additional_param({sorted: [-> (v, w) { v }, ['true', 'false', 'maybe']]}, 'ranged')
+        )
+      end.to raise_error(RiceCooker::InvalidRangeValueException)
+    end
+  end
+
+  describe 'Additional params must be correctly formated' do
+
+    it 'No additional params' do
+      formated = format_additional_param({}, 'ranged')
+      expect(formated).to be_eql({})
+    end
+
+    it 'Already correctly formatted additional params' do
+      p = {range: {
+        proc: @proc,
+        all: [1, 2, 3],
+        description: 'A good filter'
+      }}
+      formated = format_additional_param(p, 'ranged')
+      expect(formated).to be_eql(p)
+    end
+
+    it 'Missing description additional params' do
+      p = {filter: {
+        proc: @proc,
+        all: [1, 2, 3]
+      }}
+      expected = {filter: {
+        proc: @proc,
+        all: [1, 2, 3],
+        description: ''
+      }}
+      formated = format_additional_param(p, 'ranged')
+      expect(formated).to be_eql(expected)
+    end
+
+    it 'Only proc additional params' do
+
+      p = {filter: @proc}
+      expected = {filter: {
+        proc: @proc,
+        all: [],
+        description: ''
+      }}
+      formated = format_additional_param(p, 'ranged')
+      expect(formated).to be_eql(expected)
+    end
+
+    it 'Array with proc and all additional params' do
+
+      p = {filter: [@proc, @all]}
+      expected = {filter: {
+        proc: @proc,
+        all: @all,
+        description: ''
+      }}
+      formated = format_additional_param(p, 'ranged')
+      expect(formated).to be_eql(expected)
+    end
+
+    it 'Multiple, std + Array with proc and all additional params' do
+
+      p = {
+        tata: @proc,
+        toto: {proc: @proc, all: [1, 2]},
+        filter: [@proc, @all],
+        tutu: {proc: @proc, description: 'Buuuuh'}
+      }
+      expected = {
+        tata: {
+          proc: @proc,
+          all: [],
+          description: ''
+        },
+        toto: {
+          proc: @proc,
+          all: [1, 2],
+          description: ''
+        },
+        filter: {
+          proc: @proc,
+          all: @all,
+          description: ''
+        },
+        tutu: {
+          proc: @proc,
+          all: [],
+          description: 'Buuuuh'
+        }
+      }
+      formated = format_additional_param(p, 'ranged')
+      expect(formated).to be_eql(expected)
+    end
+
+  end
+end
+
+RSpec.describe UsersController, type: :controller do
+  include RiceCooker::Helpers
+
+  before { request.host = 'example.org' }
+
+  describe 'GET #index' do
+    it 'without range parameter' do
+      process :index, method: :get, params: { range: '', format: :json }
+      expect(response.body).to eq(User.all.order(id: :desc).to_json)
+    end
+
+    it 'with simple range parameter' do
+      process :index, method: :get, params: { range: { login: 'aaubin,qbollach' }, format: :json }
+      expect(response.body).to eq(User.where(login: 'aaubin'..'qbollach').order(id: :desc).to_json)
+    end
+
+    it 'with multiple range parameter' do
+      process :index, method: :get, params: { range: { login: 'aaubin,qbollach', id: '1,5' }, format: :json }
+      expect(response.body).to eq(User.where(login: 'aaubin'..'qbollach', id: 1..5).order(id: :desc).to_json)
+    end
+
+    it 'with invalid range parameter' do
+      expect do
+        process :index, method: :get, params: { range: { created_at: '2016-02-04,qbollach', login: '^,&' }, format: :json }
+      end.to raise_error(RiceCooker::InvalidRangeException)
+    end
+  end
+end