miscellany 0.1.0 → 0.1.4

data/spec/miscellany/arbitrary_prefetch_spec.rb

@@ -0,0 +1,69 @@
+
+require 'spec_helper'
+
+describe Miscellany::ArbitraryPrefetch do
+  with_model :Post do
+    table do |t|
+      t.string :title
+      t.timestamps null: false
+    end
+
+    model do
+      has_many :comments
+    end
+  end
+
+  with_model :Comment do
+    table do |t|
+      t.belongs_to :post
+      t.string :title
+      t.boolean :favorite
+      t.timestamps null: false
+    end
+
+    model do
+      belongs_to :post
+    end
+  end
+
+  let!(:posts) { 10.times.map{|i| Post.create!(title: "Post #{i}") } }
+
+  before :each do
+    posts.each do |p|
+      5.times{|i| p.comments.create!(title: "#{p.title} Comment #{i}") }
+      p.comments.last.update!(favorite: true)
+    end
+  end
+
+  it 'generally works' do
+    posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
+    expect(posts.count).to eq 10
+    expect(posts[0].favorite_comment).to be
+  end
+
+  context 'prefetch is singluar' do
+    it 'returns a single object' do
+      posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
+      expect(posts[0].favorite_comment).to be_a Comment
+    end
+
+    it 'with multiple items returns a single object' do
+      posts = Post.prefetch(favorite_comment: Comment.where(favorite: nil))
+      expect(posts[0].favorite_comment).to be_a Comment
+    end
+  end
+
+  context 'prefetch is plural' do
+    it 'returns an Array' do
+      posts = Post.prefetch(non_favorite_comments: Comment.where(favorite: nil))
+      expect(posts[0].non_favorite_comments).to respond_to :[]
+      expect(posts[0].non_favorite_comments.length).to eq 4
+    end
+
+    it 'with 1 item returns an Array' do
+      posts = Post.prefetch(non_favorite_comments: Comment.where(favorite: true))
+      expect(posts[0].non_favorite_comments).to respond_to :[]
+      expect(posts[0].non_favorite_comments.length).to eq 1
+    end
+  end
+end

data/spec/miscellany/computed_columns_spec.rb

@@ -0,0 +1,62 @@
+
+require 'spec_helper'
+
+describe Miscellany::ComputedColumns do
+  with_model :Post do
+    table do |t|
+      t.string :title
+      t.timestamps null: false
+    end
+
+    model do
+      has_many :comments
+
+      define_computed :favorite_comments_count, ->() {
+        select "COMPUTED.count AS favorite_comments_count"
+
+        query do
+          Comment.select(<<~SQL)
+              post_id AS id,
+              count(*) AS count
+            SQL
+          .group(:post_id)
+            .where(favorite: true)
+        end
+      }
+    end
+  end
+
+  with_model :Comment do
+    table do |t|
+      t.belongs_to :post
+      t.string :title
+      t.boolean :favorite
+      t.timestamps null: false
+    end
+
+    model do
+      belongs_to :post
+    end
+  end
+
+  let!(:posts) { 3.times.map{|i| Post.create!(title: "Post #{i}") } }
+
+  before :each do
+    posts.each do |p|
+      5.times{|i| p.comments.create!(title: "#{p.title} Comment #{i}") }
+      p.comments.last.update!(favorite: true)
+    end
+  end
+
+  it 'generally works' do
+    ActiveRecord::Base.verbose_query_logs = true
+    posts = Post.with_computed(:favorite_comments_count)
+    expect(posts.except(:select).count).to eq 3
+    expect(posts[0].favorite_comments_count).to eq 1
+
+    Comment.update_all(favorite: true)
+    posts = Post.with_computed(:favorite_comments_count)
+    expect(posts.except(:select).count).to eq 3
+    expect(posts[0].favorite_comments_count).to eq 5
+  end
+end

data/spec/miscellany/param_validator_spec.rb

@@ -0,0 +1,295 @@
+
+require 'spec_helper'
+
+describe Miscellany::ParamValidator do
+  let!(:value) do
+    {
+      int_array: [1,2,3],
+      string_array: %w[A B C],
+      some_number: 2,
+      some_string: "Robert",
+      specified: nil,
+      array: [
+        {a: 2},
+        {a: 3},
+      ],
+      hash: {
+        nested_hash: {
+          value: 1,
+        }
+      },
+    }
+  end
+
+  # TODO transform:
+
+  def expect_valid(&blk)
+    result = Miscellany::ParamValidator.check(value, &blk)
+    expect(result.serialize).to be_nil
+  end
+
+  def expect_invalid(&blk)
+    result = Miscellany::ParamValidator.check(value, &blk)
+    expect(result.serialize).to be_present
+  end
+
+  def expect_coercion(raw, type, expectation)
+    result = Miscellany::ParamValidator.assert({ value: raw }, handle: ->(v){ raise 'Invalid' }) do
+      p :value, type: type
+    end
+    expect(result[:value]).to eq expectation
+  end
+
+  describe 'default:' do
+    it 'sets a default value' do
+      result = Miscellany::ParamValidator.assert({ }, handle: ->(v){ raise 'Invalid' }) do
+        p :value, default: 'HIA'
+      end
+      expect(result[:value]).to eq 'HIA'
+    end
+
+    it 'works deep' do
+      result = Miscellany::ParamValidator.assert({ value: {} }, handle: ->(v){ raise 'Invalid' }) do
+        p :value do |x|
+          p :value, default: 'Hia'
+        end
+      end
+      expect(result).to eq ({ value: { value: 'Hia' } })
+    end
+  end
+
+  describe 'specified' do
+    it 'passes a given value' do
+      expect_valid do
+        p :some_string, :specified
+      end
+    end
+
+    it 'passes a given nil' do
+      expect_valid do
+        p :specified, :specified
+      end
+    end
+
+    it 'fails an unspecified key' do
+      expect_invalid do
+        p :not_specified, :specified
+      end
+    end
+  end
+
+  describe 'present' do
+    it 'passes a given value' do
+      expect_valid do
+        p :some_string, :present
+      end
+    end
+
+    it 'fails a given nil' do
+      expect_invalid do
+        p :specified, :present
+      end
+    end
+
+    it 'fails an unspecified key' do
+      expect_invalid do
+        p :not_specified, :present
+      end
+    end
+  end
+
+  describe 'type:' do
+    it 'passes based on type' do
+      expect_valid do
+        p :some_number, type: Numeric
+        p :some_string, type: String
+      end
+    end
+
+    it 'fails based on type' do
+      expect_invalid do
+        p :some_number, type: String
+        p :some_string, type: Numeric
+      end
+    end
+
+    describe ':bool' do
+      it 'transforms booleans' do
+        expect_coercion('t', :bool, true)
+        expect_coercion('T', :bool, true)
+        expect_coercion('true', :bool, true)
+        expect_coercion('True', :bool, true)
+        expect_coercion('TRUE', :bool, true)
+        expect_coercion('YES', :bool, true)
+        expect_coercion('yes', :bool, true)
+        expect_coercion('Y', :bool, true)
+        expect_coercion('y', :bool, true)
+        expect_coercion('1', :bool, true)
+        expect_coercion(1, :bool, true)
+
+        expect_coercion('f', :bool, false)
+        expect_coercion('F', :bool, false)
+        expect_coercion('false', :bool, false)
+        expect_coercion('False', :bool, false)
+        expect_coercion('FALSE', :bool, false)
+        expect_coercion('NO', :bool, false)
+        expect_coercion('no', :bool, false)
+        expect_coercion('N', :bool, false)
+        expect_coercion('n', :bool, false)
+        expect_coercion('0', :bool, false)
+        expect_coercion(0, :bool, false)
+      end
+    end
+  end
+
+  describe 'in:' do
+    it 'works' do
+      expect_valid do
+        p :some_number, in: [1, 2]
+      end
+
+      expect_invalid do
+        p :some_number, in: [1, 3]
+      end
+    end
+
+    it 'works with modifiers' do
+      expect_valid do
+        p [:some_number, :some_string], one_in: [2]
+        p [:some_number, :some_string], one_in: ['Robert']
+        p [:some_number, :some_string], none_in: ['Steve', 3]
+      end
+    end
+  end
+
+  describe 'pattern:' do
+    it 'works' do
+      expect_valid do
+        p :some_string, pattern: /^Rob/
+        p :some_string, pattern: /^Robert$/
+      end
+      expect_invalid do
+        p :some_string, pattern: /^Steve$/
+      end
+    end
+  end
+
+  describe 'items:' do
+    it 'works when given a Lambda' do
+      expect_valid do
+        p :array, items: ->(*args) {
+          p :a, in: [2, 3]
+          nil
+        }
+      end
+      expect_invalid do
+        p :array, items: ->(*args) {
+          p :a, in: [5]
+        }
+      end
+      expect_invalid do
+        p :array, items: ->(*args) {
+          'bob'
+        }
+      end
+    end
+    it 'works when given a Hash' do
+      # TODO
+    end
+  end
+
+  it 'supports a custom validator block' do
+    expect_valid do
+      p :some_string do |v|
+        nil
+      end
+    end
+
+    expect_invalid do
+      p :some_string do |v|
+        'Bad Length'
+      end
+    end
+  end
+
+  describe 'modifiers' do
+    let!(:value) do
+      {
+        a: 1,
+        b: 1,
+        c: 1,
+        x: nil,
+        y: nil,
+        z: nil,
+      }
+    end
+
+    def assert_modifier(modifier, keys, exp)
+      blk = ->(*args) {
+        p keys, :"#{modifier}_present"
+      }
+      exp ? expect_valid(&blk) : expect_invalid(&blk)
+    end
+
+    it 'the all modifier works as expected' do
+      assert_modifier(:all, %i[a b c], true)
+      assert_modifier(:all, %i[a b z], false)
+      assert_modifier(:all, %i[a y z], false)
+      assert_modifier(:all, %i[x y z], false)
+    end
+
+    it 'the onem modifier works as expected' do
+      assert_modifier(:onem, %i[a b c], false)
+      assert_modifier(:onem, %i[a b z], false)
+      assert_modifier(:onem, %i[a y z], true)
+      assert_modifier(:onem, %i[x y z], true)
+    end
+
+    it 'the onep modifier works as expected' do
+      assert_modifier(:onep, %i[a b c], true)
+      assert_modifier(:onep, %i[a b z], true)
+      assert_modifier(:onep, %i[a y z], true)
+      assert_modifier(:onep, %i[x y z], false)
+    end
+
+    it 'the one modifier works as expected' do
+      assert_modifier(:one, %i[a b c], false)
+      assert_modifier(:one, %i[a b z], false)
+      assert_modifier(:one, %i[a y z], true)
+      assert_modifier(:one, %i[x y z], false)
+    end
+
+    it 'the none modifier works as expected' do
+      assert_modifier(:none, %i[a b c], false)
+      assert_modifier(:none, %i[a b z], false)
+      assert_modifier(:none, %i[a y z], false)
+      assert_modifier(:none, %i[x y z], true)
+    end
+
+    it 'aliases work' do
+      assert_modifier(:any, %i[a b c], true)
+      assert_modifier(:any, %i[a b z], true)
+      assert_modifier(:any, %i[a y z], true)
+      assert_modifier(:any, %i[x y z], false)
+    end
+  end
+
+  describe 'nesting' do
+    it 'works' do
+      expect_valid do
+        p :hash, :present do
+          p :nested_hash do
+            p :value, in: [1]
+          end
+        end
+      end
+      expect_invalid do
+        p :hash, :present do
+          p :nested_hash do
+            p :value, not_in: [1]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'yaml'
+require 'database_cleaner'
+require 'with_model'
+
+require 'miscellany'
+
+FileUtils.makedirs('log')
+
+ActiveRecord::Base.logger = Logger.new('log/test.log')
+ActiveRecord::Base.logger.level = Logger::DEBUG
+ActiveRecord::Migration.verbose = false
+
+db_adapter = ENV.fetch('ADAPTER', 'sqlite3')
+db_config = YAML.safe_load(File.read('spec/db/database.yml'))
+ActiveRecord::Base.establish_connection(db_config[db_adapter])
+
+RSpec.configure do |config|
+  config.extend WithModel
+
+  # config.order = 'random'
+
+  config.before(:suite) do
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before do
+    DatabaseCleaner.strategy = :transaction
+  end
+
+  config.before do
+    DatabaseCleaner.start
+  end
+
+  config.after do
+    DatabaseCleaner.clean
+  end
+end
+
+puts "Testing with ActiveRecord #{ActiveRecord::VERSION::STRING}"