arel-helpers 2.11.0 → 2.12.0

data/spec/join_association_spec.rb

@@ -1,94 +1,137 @@
-# encoding: UTF-8
-
 require 'spec_helper'
 
 describe ArelHelpers do
-  describe "#join_association" do
-    it "should work for a directly associated model" do
-      Post.joins(ArelHelpers.join_association(Post, :comments)).to_sql.should ==
-        'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"'
+  describe '#join_association' do
+    it 'should work for a directly associated model' do
+      expect(Post.joins(ArelHelpers.join_association(Post, :comments)).to_sql).to(
+        eq('SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"')
+      )
     end
 
-    it "should work with an outer join" do
-      Post.joins(ArelHelpers.join_association(Post, :comments, Arel::Nodes::OuterJoin)).to_sql.should ==
-        'SELECT "posts".* FROM "posts" LEFT OUTER JOIN "comments" ON "comments"."post_id" = "posts"."id"'
+    it 'should work with an outer join' do
+      expect(Post.joins(ArelHelpers.join_association(Post, :comments, Arel::Nodes::OuterJoin)).to_sql).to(
+        eq('SELECT "posts".* FROM "posts" LEFT OUTER JOIN "comments" ON "comments"."post_id" = "posts"."id"')
+      )
     end
 
-    it "should allow adding additional join conditions" do
-      Post.joins(ArelHelpers.join_association(Post, :comments) do |assoc_name, join_conditions|
+    it 'should allow adding additional join conditions' do
+      sql = Post.joins(ArelHelpers.join_association(Post, :comments) do |_assoc_name, join_conditions|
         join_conditions.and(Comment[:id].eq(10))
-      end).to_sql.should ==
-        'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" AND "comments"."id" = 10'
+      end).to_sql
+
+      expect(sql).to eq <<-SQL.squish
+        SELECT "posts".* FROM "posts"
+          INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" AND "comments"."id" = 10
+      SQL
     end
 
-    it "should work for two models, one directly associated and the other indirectly" do
-      Post
-        .joins(ArelHelpers.join_association(Post, :comments))
-        .joins(ArelHelpers.join_association(Comment, :author))
-        .to_sql.should ==
-          'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" INNER JOIN "authors" ON "authors"."id" = "comments"."author_id"'
+    it 'should work for two models, one directly associated and the other indirectly' do
+      sql = Post
+              .joins(ArelHelpers.join_association(Post, :comments))
+              .joins(ArelHelpers.join_association(Comment, :author))
+              .to_sql
+
+      expect(sql).to eq <<-SQL.squish
+        SELECT "posts".* FROM "posts"
+          INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+          INNER JOIN "authors" ON "authors"."id" = "comments"."author_id"
+      SQL
     end
 
-    it "should work for a nested hash of association names" do
-      Post
-        .joins(ArelHelpers.join_association(Post, { comments: :author }))
-        .to_sql.should ==
-          'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" INNER JOIN "authors" ON "authors"."id" = "comments"."author_id"'
+    it 'should work for a nested hash of association names' do
+      sql = Post
+              .joins(ArelHelpers.join_association(Post, { comments: :author }))
+              .to_sql
+
+      expect(sql).to eq <<-SQL.squish
+        SELECT "posts".* FROM "posts"
+          INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+          INNER JOIN "authors" ON "authors"."id" = "comments"."author_id"
+      SQL
     end
 
-    it "should work with outer joins when given a nested hash of association names" do
-      Post
-        .joins(ArelHelpers.join_association(Post, { comments: :author }, Arel::Nodes::OuterJoin))
-        .to_sql.should ==
-          'SELECT "posts".* FROM "posts" LEFT OUTER JOIN "comments" ON "comments"."post_id" = "posts"."id" LEFT OUTER JOIN "authors" ON "authors"."id" = "comments"."author_id"'
+    it 'should work with outer joins when given a nested hash of association names' do
+      sql = Post.joins(ArelHelpers.join_association(Post, { comments: :author }, Arel::Nodes::OuterJoin)).to_sql
+
+      expect(sql).to eq <<-SQL.squish
+        SELECT "posts".* FROM "posts"
+          LEFT OUTER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+          LEFT OUTER JOIN "authors" ON "authors"."id" = "comments"."author_id"
+      SQL
     end
 
-    it "should be able to handle multiple associations" do
-      Post.joins(ArelHelpers.join_association(Post, [:comments, :favorites])).to_sql.should ==
-        'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" INNER JOIN "favorites" ON "favorites"."post_id" = "posts"."id"'
+    it 'should be able to handle multiple associations' do
+      expect(Post.joins(ArelHelpers.join_association(Post, %i[comments favorites])).to_sql).to(
+        eq <<-SQL.squish
+          SELECT "posts".* FROM "posts"
+            INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+            INNER JOIN "favorites" ON "favorites"."post_id" = "posts"."id"
+      SQL
+      )
     end
 
-    it "should yield once for each association" do
-      Post.joins(ArelHelpers.join_association(Post, [:comments, :favorites]) do |assoc_name, join_conditions|
+    it 'should yield once for each association' do
+      sql = Post.joins(ArelHelpers.join_association(Post, %i[comments favorites]) do |assoc_name, join_conditions|
         case assoc_name
-          when :favorites
-            join_conditions.or(Favorite[:amount].eq("lots"))
-          when :comments
-            join_conditions.and(Comment[:text].eq("Awesome post!"))
+        when :favorites
+          join_conditions.or(Favorite[:amount].eq('lots'))
+        when :comments
+          join_conditions.and(Comment[:text].eq('Awesome post!'))
         end
-      end).to_sql.should ==
-        'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" AND "comments"."text" = \'Awesome post!\' INNER JOIN "favorites" (ON "favorites"."post_id" = "posts"."id" OR "favorites"."amount" = \'lots\')'
+      end).to_sql
+
+      expect(sql).to eq <<-SQL.squish
+        SELECT "posts".* FROM "posts"
+          INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" AND "comments"."text" = 'Awesome post!'
+          INNER JOIN "favorites" (ON "favorites"."post_id" = "posts"."id" OR "favorites"."amount" = 'lots')
+      SQL
     end
 
     it 'should be able to handle has_and_belongs_to_many associations' do
-      CollabPost.joins(ArelHelpers.join_association(CollabPost, :authors)).to_sql.should ==
-        'SELECT "collab_posts".* FROM "collab_posts" INNER JOIN "authors_collab_posts" ON "authors_collab_posts"."collab_post_id" = "collab_posts"."id" INNER JOIN "authors" ON "authors"."id" = "authors_collab_posts"."author_id"'
+      sql = CollabPost.joins(ArelHelpers.join_association(CollabPost, :authors)).to_sql
+
+      expect(sql).to eq <<-SQL.squish
+        SELECT "collab_posts".* FROM "collab_posts"
+          INNER JOIN "authors_collab_posts" ON "authors_collab_posts"."collab_post_id" = "collab_posts"."id"
+          INNER JOIN "authors" ON "authors"."id" = "authors_collab_posts"."author_id"
+      SQL
     end
 
-    it "allows adding a custom alias to the joined table" do
+    it 'allows adding a custom alias to the joined table' do
       Comment.aliased_as(:foo) do |foo|
-        Post.joins(ArelHelpers.join_association(Post, :comments, Arel::Nodes::InnerJoin, aliases: [foo])).to_sql.should ==
-          'SELECT "posts".* FROM "posts" INNER JOIN "comments" "foo" ON "foo"."post_id" = "posts"."id"'
+        sql = Post.joins(
+          ArelHelpers.join_association(Post, :comments, Arel::Nodes::InnerJoin, aliases: [foo])
+        ).to_sql
+
+        expect(sql).to eq 'SELECT "posts".* FROM "posts" INNER JOIN "comments" "foo" ON "foo"."post_id" = "posts"."id"'
       end
     end
 
-    it "allows aliasing multiple associations" do
+    it 'allows aliasing multiple associations' do
       Comment.aliased_as(:foo) do |foo|
         Favorite.aliased_as(:bar) do |bar|
-          Post.joins(ArelHelpers.join_association(Post, [:comments, :favorites], Arel::Nodes::InnerJoin, aliases: [foo, bar])).to_sql.should ==
-            'SELECT "posts".* FROM "posts" INNER JOIN "comments" "foo" ON "foo"."post_id" = "posts"."id" INNER JOIN "favorites" "bar" ON "bar"."post_id" = "posts"."id"'
+          sql = Post.joins(
+            ArelHelpers.join_association(Post, %i[comments favorites], Arel::Nodes::InnerJoin, aliases: [foo, bar])
+          ).to_sql
+
+          expect(sql).to eq <<-SQL.squish
+            SELECT "posts".* FROM "posts"
+              INNER JOIN "comments" "foo" ON "foo"."post_id" = "posts"."id"
+              INNER JOIN "favorites" "bar" ON "bar"."post_id" = "posts"."id"
+          SQL
         end
       end
     end
 
     it 'handles polymorphic through associations' do
-      relation = Location.joins(
-        ArelHelpers.join_association(Location, :community_tickets)
-      )
+      location = Location.create!
+      ticket = CommunityTicket.create!
+      CardLocation.create! card: ticket, location: location
+
+      relation = Location.joins(ArelHelpers.join_association(Location, :community_tickets))
 
-      relation.to_sql.should == 'SELECT "locations".* FROM "locations" ' +
-        'INNER JOIN "card_locations" ON "card_locations"."location_id" = "locations"."id" AND "card_locations"."card_type" = \'CommunityTicket\' ' +
-        'INNER JOIN "community_tickets" ON "community_tickets"."id" = "card_locations"."card_id"'
+      expect(relation.count).to eq 1
+      expect(relation.to_a).to include location
     end
   end
 end
@@ -98,8 +141,9 @@ describe ArelHelpers::JoinAssociation do
     include ArelHelpers::JoinAssociation
   end
 
-  it "should provide the join_association method and use the parent class as the model to join on" do
-    AssocPost.joins(AssocPost.join_association(:comments)).to_sql.should ==
-      'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"'
+  it 'should provide the join_association method and use the parent class as the model to join on' do
+    expect(AssocPost.joins(AssocPost.join_association(:comments)).to_sql).to eq <<-SQL.squish
+      SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+    SQL
   end
 end

data/spec/query_builder_spec.rb

@@ -1,5 +1,3 @@
-# encoding: UTF-8
-
 require 'spec_helper'
 
 class TestQueryBuilder < ArelHelpers::QueryBuilder
@@ -15,60 +13,61 @@ class TestQueryBuilder < ArelHelpers::QueryBuilder
   end
 
   not_nil def optional(skip:)
-    reflect(query.where(title: "BarBar")) unless skip
+    reflect(query.where(title: 'BarBar')) unless skip
   end
 end
 
 describe ArelHelpers::QueryBuilder do
   let(:builder) { TestQueryBuilder.new }
 
-  it "returns (i.e. reflects) new instances of QueryBuilder" do
+  it 'returns (i.e. reflects) new instances of QueryBuilder' do
     builder.tap do |original_builder|
       original_builder.params = true
       new_builder = original_builder.noop
-      new_builder.object_id.should_not == original_builder.object_id
-      new_builder.params?.should == true
+      expect(new_builder.object_id).not_to eq original_builder.object_id
+      expect(new_builder.params?).to be true
     end
   end
 
-  it "forwards #to_a" do
-    Post.create(title: "Foobar")
+  it 'forwards #to_a' do
+    Post.create(title: 'Foobar')
     builder.to_a.tap do |posts|
-      posts.size.should == 1
-      posts.first.title.should == "Foobar"
+      expect(posts.size).to eq 1
+      expect(posts.first.title).to eq 'Foobar'
     end
   end
 
-  it "forwards #to_sql" do
-    builder.to_sql.strip.should == 'SELECT "posts".* FROM "posts"'
+  it 'forwards #to_sql' do
+    expect(builder.to_sql.strip).to eq 'SELECT "posts".* FROM "posts"'
   end
 
-  it "forwards #each" do
-    created_post = Post.create(title: "Foobar")
+  it 'forwards #each' do
+    created_post = Post.create(title: 'Foobar')
     builder.each do |post|
-      post.should == created_post
+      expect(post).to eq created_post
     end
   end
 
-  it "forwards other enumerable methods via #each" do
-    Post.create(title: "Foobar")
-    builder.map(&:title).should == ["Foobar"]
+  it 'forwards other enumerable methods via #each' do
+    Post.create(title: 'Foobar')
+    expect(builder.map(&:title)).to eq ['Foobar']
   end
 
   ArelHelpers::QueryBuilder::TERMINAL_METHODS.each do |method|
     it "does not enumerate records for #{method}" do
-      mock(builder).each.never
+      allow(builder).to receive :each
       builder.public_send(method)
+      expect(builder).not_to have_received :each
     end
   end
 
-  it "returns reflect on existing query if method returns a falsy value" do
-    builder.optional(skip: true).to_sql.strip.should == 'SELECT "posts".* FROM "posts"'
+  it 'returns reflect on existing query if method returns a falsy value' do
+    expect(builder.optional(skip: true).to_sql.strip).to eq 'SELECT "posts".* FROM "posts"'
   end
 
-  it "returns reflect on new query for default chainable method if value is truthy" do
-    builder.optional(skip: false).to_sql.strip.gsub(/\s+/, " ").should == %Q{
-      SELECT \"posts\".* FROM \"posts\" WHERE \"posts\".\"title\" = 'BarBar'
-    }.strip
+  it 'returns reflect on new query for default chainable method if value is truthy' do
+    expect(builder.optional(skip: false).to_sql.strip.gsub(/\s+/, ' ')).to eq <<-SQL.squish
+      SELECT "posts".* FROM "posts" WHERE "posts"."title" = 'BarBar'
+    SQL
   end
 end

data/spec/spec_helper.rb

@@ -1,29 +1,20 @@
-# encoding: UTF-8
-
-$:.push(File.dirname(__FILE__))
+$LOAD_PATH.push(File.dirname(__FILE__))
 
 require 'rspec'
 require 'arel-helpers'
 require 'fileutils'
 
-require 'env'
+require 'combustion'
+Combustion.initialize! :active_record
 
-def silence(&block)
-  original_stdout = $stdout
-  $stdout = StringIO.new
-  begin
-    yield
-  ensure
-    $stdout = original_stdout
-  end
-end
+require 'database_cleaner'
+require 'env/models'
 
 RSpec.configure do |config|
-  config.mock_with :rr
+  DatabaseCleaner.strategy = :transaction
+
+  config.before(:suite) { DatabaseCleaner.clean_with :truncation }
 
-  config.before(:each) do
-    ArelHelpers::Env.establish_connection
-    ArelHelpers::Env.reset
-    silence { ArelHelpers::Env.migrate }
-  end
+  config.before { DatabaseCleaner.start }
+  config.after  { DatabaseCleaner.clean }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arel-helpers
 version: !ruby/object:Gem::Version
-  version: 2.11.0
+  version: 2.12.0
 platform: ruby
 authors:
 - Cameron Dutro
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-21 00:00:00.000000000 Z
+date: 2020-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -30,6 +30,48 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '7'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: combustion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -50,28 +92,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: '3'
 - !ruby/object:Gem::Dependency
-  name: rr
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.4.0
 description: Useful tools to help construct database queries with ActiveRecord and
   Arel.
 email:
@@ -93,9 +135,11 @@ files:
 - lib/arel-helpers/version.rb
 - spec/aliases_spec.rb
 - spec/arel_table_spec.rb
-- spec/env.rb
-- spec/env/migrations.rb
 - spec/env/models.rb
+- spec/internal/config/database.yml
+- spec/internal/db/combustion_test.sqlite
+- spec/internal/db/schema.rb
+- spec/internal/log/test.log
 - spec/join_association_spec.rb
 - spec/query_builder_spec.rb
 - spec/spec_helper.rb
@@ -103,7 +147,7 @@ homepage: https://github.com/camertron/arel-helpers
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -118,8 +162,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Useful tools to help construct database queries with ActiveRecord and Arel.
 test_files: []