active_hash_relation 1.1.0 → 1.2.0

data/spec/models/address.rb

@@ -0,0 +1,7 @@
+require_relative './application_record'
+
+class Address < ApplicationRecord
+  belongs_to :user
+
+  scope :in_sweden, -> { where(country: 'SE') }
+end

data/spec/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/spec/models/micropost.rb

@@ -0,0 +1,9 @@
+require_relative './application_record'
+
+class Micropost < ApplicationRecord
+  belongs_to :user, counter_cache: true
+
+  enum status: {draft: 0, published: 1, archived: 2 }
+
+  scope :created_on, ->(date) {where("date(microposts.created_at) = ?", date.to_date)}
+end

data/spec/models/relationship.rb

@@ -0,0 +1,9 @@
+require_relative './application_record'
+
+class Relationship < ApplicationRecord
+  belongs_to :follower, class_name: "User", counter_cache: :followings_count
+  belongs_to :followed, class_name: "User", counter_cache: :followers_count
+
+  validates :follower_id, presence: true
+  validates :followed_id, presence: true
+end

data/spec/models/user.rb

@@ -0,0 +1,32 @@
+require_relative './application_record'
+
+class User < ApplicationRecord
+  has_many :microposts, dependent: :destroy
+  has_many :active_relationships, class_name:  "Relationship",
+                                  foreign_key: "follower_id",
+                                  dependent:   :destroy
+  has_many :passive_relationships, class_name:  "Relationship",
+                                   foreign_key: "followed_id",
+                                   dependent:   :destroy
+  has_many :following, through: :active_relationships,  source: :followed
+  has_many :followers, through: :passive_relationships, source: :follower
+  has_one :address
+
+  before_validation :ensure_token
+
+  scope :unverified, -> {where(verified: false)}
+  scope :unsocial, -> {where(followings_count: 0, followers_count: 0)}
+  scope :created_on, ->(date) {where("date(created_at) = ?", date.to_date)}
+
+  private
+    def ensure_token
+      self.token = generate_hex(:token) unless token.present?
+    end
+
+    def generate_hex(column)
+      loop do
+        hex = SecureRandom.hex
+        break hex unless self.class.where(column => hex).any?
+      end
+    end
+end

data/spec/support/support.rb

@@ -0,0 +1,62 @@
+RSpec.configure do |config|
+  config.before :suite do
+    DatabaseCleaner[:active_record].strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+
+  config.before(:suite) do
+    begin
+      DatabaseCleaner.start
+      FactoryGirl.lint
+    ensure
+      DatabaseCleaner.clean
+    end
+  end
+end
+
+class HelperClass
+  include ActiveHashRelation
+end
+
+module Helpers
+  def strip(query)
+    query.gsub("\"","").gsub(/\s+/, ' ')
+  end
+
+  def select_all(table)
+    ExpectedQuery.new("SELECT #{table}.* FROM users WHERE")
+  end
+  alias_method :select_all_where, :select_all
+
+  def query(str)
+    ExpectedQuery.new(str, subquery: true)
+  end
+
+  def q(*args)
+    args.each.with_index.inject(''){|memo, (str, index)|
+      if args[index-1] == '('
+        "#{memo}#{str}"
+      elsif str == ')'
+        "#{memo}#{str}"
+      else
+        "#{memo} #{str}"
+      end
+    }.strip
+  end
+end
+
+class Array
+  def avg
+    sum / size.to_f
+  end
+end

data/spec/tests/aggregations/avg_spec.rb

@@ -0,0 +1,45 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  context 'aggregations' do
+    context 'avg' do
+      before do
+        FactoryGirl.create_list(:micropost, 10)
+      end
+
+      it "one aggregation" do
+        hash = { aggregate: {likes: {avg: true} } }
+
+        aggregations = HelperClass.new.aggregations(Micropost.all, hash)
+        expected_aggregations = HashWithIndifferentAccess.new({
+          likes: {
+            avg: Micropost.pluck(:likes).avg
+          }
+        })
+        expect(aggregations).to eq expected_aggregations
+      end
+      it "multiple aggregations" do
+        hash = {
+          aggregate: {
+            likes: {avg: true}, reposts: {avg: true}, created_at: {avg: true}
+          }
+        }
+
+        aggregations = HelperClass.new.aggregations(Micropost.all, hash)
+        expected_aggregations = HashWithIndifferentAccess.new({
+          likes: {
+            avg: Micropost.pluck(:likes).avg
+          },
+          reposts: {
+            avg: Micropost.pluck(:reposts).avg
+          },
+          created_at: {}
+        })
+        expect(aggregations).to eq expected_aggregations
+      end
+
+    end
+  end
+end
+
+

data/spec/tests/aggregations/max_spec.rb

@@ -0,0 +1,45 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  context 'aggregations' do
+    context 'max' do
+      before do
+        FactoryGirl.create_list(:micropost, 10)
+      end
+
+      it "one aggregation" do
+        hash = { aggregate: {likes: {max: true} } }
+
+        aggregations = HelperClass.new.aggregations(Micropost.all, hash)
+        expected_aggregations = HashWithIndifferentAccess.new({
+          likes: {
+            max: Micropost.pluck(:likes).max
+          }
+        })
+        expect(aggregations).to eq expected_aggregations
+      end
+      it "multiple aggregations" do
+        hash = {
+          aggregate: {
+            likes: {max: true}, reposts: {max: true}, created_at: {max: true}
+          }
+        }
+
+        aggregations = HelperClass.new.aggregations(Micropost.all, hash)
+        expected_aggregations = HashWithIndifferentAccess.new({
+          likes: {
+            max: Micropost.pluck(:likes).max,
+          },
+          reposts: {
+            max: Micropost.pluck(:reposts).max,
+          },
+          created_at: {
+            max: Micropost.pluck(:created_at).max.to_time
+          }
+        })
+        expect(aggregations).to eq expected_aggregations
+      end
+
+    end
+  end
+end

data/spec/tests/aggregations/min_spec.rb

@@ -0,0 +1,46 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  context 'aggregations' do
+    context 'min' do
+      before do
+        FactoryGirl.create_list(:micropost, 10)
+      end
+
+      it "one aggregation" do
+        hash = { aggregate: {likes: {min: true} } }
+
+        aggregations = HelperClass.new.aggregations(Micropost.all, hash)
+        expected_aggregations = HashWithIndifferentAccess.new({
+          likes: {
+            min: Micropost.pluck(:likes).min
+          }
+        })
+        expect(aggregations).to eq expected_aggregations
+      end
+      it "multiple aggregations" do
+        hash = {
+          aggregate: {
+            likes: {min: true}, reposts: {min: true}, created_at: {min: true}
+          }
+        }
+
+        aggregations = HelperClass.new.aggregations(Micropost.all, hash)
+        expected_aggregations = HashWithIndifferentAccess.new({
+          likes: {
+            min: Micropost.pluck(:likes).min
+          },
+          reposts: {
+            min: Micropost.pluck(:reposts).min
+          },
+          created_at: {
+            min: Micropost.pluck(:created_at).min.to_time
+          }
+        })
+        expect(aggregations).to eq expected_aggregations
+      end
+
+    end
+  end
+end
+

data/spec/tests/aggregations/sum_spec.rb

@@ -0,0 +1,43 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  context 'aggregations' do
+    context 'sum' do
+      before do
+        FactoryGirl.create_list(:micropost, 10)
+      end
+
+      it "one aggregation" do
+        hash = { aggregate: {likes: {sum: true} } }
+
+        aggregations = HelperClass.new.aggregations(Micropost.all, hash)
+        expected_aggregations = HashWithIndifferentAccess.new({
+          likes: {
+            sum: Micropost.pluck(:likes).sum
+          }
+        })
+        expect(aggregations).to eq expected_aggregations
+      end
+      it "multiple aggregations" do
+        hash = {
+          aggregate: {
+            likes: {sum: true}, reposts: {sum: true}, created_at: {sum: true}
+          }
+        }
+
+        aggregations = HelperClass.new.aggregations(Micropost.all, hash)
+        expected_aggregations = HashWithIndifferentAccess.new({
+          likes: {
+            sum: Micropost.pluck(:likes).sum
+          },
+          reposts: {
+            sum: Micropost.pluck(:reposts).sum
+          },
+          created_at: {}
+        })
+        expect(aggregations).to eq expected_aggregations
+      end
+
+    end
+  end
+end

data/spec/tests/associations/belongs_to_spec.rb

@@ -0,0 +1,96 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  context 'associations' do
+    context 'belongs_to' do
+      it "one where clause" do
+        hash = {user: {name: 'Filippos' }}
+
+        query = HelperClass.new.apply_filters(Micropost.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT microposts.* FROM microposts",
+          "INNER JOIN users ON users.id = microposts.user_id",
+          "WHERE (users.name = 'Filippos')"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+      it "multiple where clause" do
+        hash = {user: {name: 'Filippos', verified: true }}
+
+        query = HelperClass.new.apply_filters(Micropost.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT microposts.* FROM microposts",
+          "INNER JOIN users ON users.id = microposts.user_id",
+          "WHERE (users.name = 'Filippos')",
+          "AND users.verified = 't'"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "multiple queries" do
+        date = DateTime.now.utc.to_s
+        hash = {
+          user: {
+            name: {starts_with: 'filippos', with_ilike: true},
+            created_at: {leq: date}
+          }
+        }
+
+        query = HelperClass.new.apply_filters(Micropost.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT microposts.* FROM microposts",
+          "INNER JOIN users ON users.id = microposts.user_id",
+          "WHERE (users.name ILIKE 'filippos%')",
+          "AND (users.created_at <= '#{date}')"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "scope" do
+        hash = {user: {scopes: {unverified: true} }}
+
+        query = HelperClass.new.apply_filters(Micropost.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT microposts.* FROM microposts",
+          "INNER JOIN users ON users.id = microposts.user_id",
+          "WHERE users.verified = 'f'"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "null" do
+        hash = {user: {name: {null: true} }}
+
+        query = HelperClass.new.apply_filters(Micropost.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT microposts.* FROM microposts",
+          "INNER JOIN users ON users.id = microposts.user_id",
+          "WHERE (users.name IS NULL)"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "sorting" do
+        hash = {user: {name: 'Filippos', sort: {property: :created_at} }}
+
+        query = HelperClass.new.apply_filters(Micropost.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT microposts.* FROM microposts",
+          "INNER JOIN users ON users.id = microposts.user_id",
+          "WHERE (users.name = 'Filippos')",
+          "ORDER BY users.created_at DESC"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+    end
+  end
+end
+
+
+

data/spec/tests/associations/has_many_spec.rb

@@ -0,0 +1,91 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  context 'associations' do
+    context 'has_many' do
+      it "one where clause" do
+        hash = {microposts: {content: 'Sveavägen 4' }}
+
+        query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "INNER JOIN microposts ON microposts.user_id = users.id",
+          "WHERE (microposts.content = 'Sveavägen 4')"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "multiple where clause" do
+        hash = {microposts: {content: 'Sveavägen 4', created_at: '2017-01-15 16:11:06 UTC' }}
+
+        query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "INNER JOIN microposts ON microposts.user_id = users.id",
+          "WHERE (microposts.content = 'Sveavägen 4')",
+          "AND microposts.created_at = '2017-01-15 16:11:06 UTC'"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "multiple queries" do
+        hash = {microposts: {content: {ends_with: '4'}, created_at: {leq: '2017-01-15 16:11:06 UTC'} }}
+
+        query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "INNER JOIN microposts ON microposts.user_id = users.id",
+          "WHERE (microposts.content LIKE '%4')",
+          "AND (microposts.created_at <= '2017-01-15 16:11:06 UTC')"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "scope" do
+        date = DateTime.now.to_date.to_s
+        hash = {microposts: {scopes: {created_on: [date] }}}
+
+        query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "INNER JOIN microposts ON microposts.user_id = users.id",
+          "WHERE (date(microposts.created_at) = '#{date}')"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "null" do
+        hash = {microposts: {content: {null: true} }}
+
+        query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "INNER JOIN microposts ON microposts.user_id = users.id",
+          "WHERE (microposts.content IS NULL)"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "sorting" do
+        hash = {microposts: {content: 'Sveavägen 4', sort: {property: :created_at} }}
+
+        query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "INNER JOIN microposts ON microposts.user_id = users.id",
+          "WHERE (microposts.content = 'Sveavägen 4')",
+          "ORDER BY microposts.created_at DESC"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+    end
+  end
+end
+
+