active_record_extended 2.1.1 → 2.2.0

data/spec/sql_inspections/window_sql_spec.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Active Record WINDOW Query inspection" do
-  describe "#define_window" do
-    context "when there is a single defined window" do
-      it "should only contain a single defined window statement at the bottom" do
-        query = Tag.define_window(:w_test).partition_by(:user_id).to_sql
-        expect(query).to eq('SELECT "tags".* FROM "tags" WINDOW w_test AS (PARTITION BY user_id)')
-      end
-
-      it "should return a single defined window with a defined ORDER BY" do
-        query = Tag.define_window(:w_test).partition_by(:user_id, order_by: { tags: { user_id: :desc } }).to_sql
-        expect(query).to end_with("WINDOW w_test AS (PARTITION BY user_id ORDER BY tags.user_id DESC)")
-      end
-
-      it "should place the window function below the WHERE and GROUP BY statements" do
-        query = Tag.define_window(:w_test).partition_by(:user_id).where(id: 1).group(:user_id).to_sql
-        expect(query).to eq('SELECT "tags".* FROM "tags" WHERE "tags"."id" = 1 GROUP BY "tags"."user_id" WINDOW w_test AS (PARTITION BY user_id)')
-      end
-    end
-
-    context "when there are multiple defined windows" do
-      it "should only contain a single defined window statement at the bottom" do
-        query =
-          Tag
-          .define_window(:test).partition_by(:user_id)
-          .define_window(:other_window).partition_by(:id)
-          .to_sql
-
-        expect(query).to end_with("WINDOW test AS (PARTITION BY user_id), other_window AS (PARTITION BY id)")
-      end
-
-      it "should contain each windows order by statements" do
-        query =
-          Tag
-          .define_window(:test).partition_by(:user_id, order_by: :id)
-          .define_window(:other_window).partition_by(:id, order_by: { tags: :user_id })
-          .to_sql
-
-        expect(query).to end_with("WINDOW test AS (PARTITION BY user_id ORDER BY id), other_window AS (PARTITION BY id ORDER BY tags.user_id ASC)")
-      end
-    end
-  end
-
-  describe "#window_select" do
-    let(:query_base)   { Tag.define_window(:w).partition_by(:user_id, order_by: :id) }
-    let(:expected_end) { "WINDOW w AS (PARTITION BY user_id ORDER BY id)" }
-
-    context "when using no argument window methods" do
-      [:row_to_number, :rank, :dense_rank, :percent_rank, :cume_dist].each do |window_function|
-        context "#{window_function.to_s.upcase}()" do
-          let(:expected_function) { "#{window_function.to_s.upcase}()" }
-          let(:query) do
-            query_base.select_window(window_function, over: :w, as: :window_response).to_sql
-          end
-
-          it "appends the function to the select query" do
-            expected_start = "SELECT (#{expected_function} OVER w) AS \"window_response\""
-            expect(query).to start_with(expected_start).and(end_with(expected_end))
-          end
-        end
-      end
-    end
-
-    context "when using an argument based window method" do
-      let(:argument_list) { ["a", 1, :sauce] }
-
-      { ntile: 1, lag: 2, lead: 3, first_value: 1, last_value: 1, nth_value: 2 }.each_pair do |window_function, arg_count|
-        context "#{window_function.to_s.upcase}/#{arg_count}" do
-          let(:arguments)         { argument_list.first(arg_count) }
-          let(:expected_function) { "#{window_function.to_s.upcase}(#{arguments.join(', ')})" }
-          let(:query) do
-            query_base.select_window(window_function, *arguments, over: :w, as: :window_response).to_sql
-          end
-
-          it "appends the function to the select query" do
-            expected_start = "SELECT (#{expected_function} OVER w) AS \"window_response\""
-            expect(query).to start_with(expected_start).and(end_with(expected_end))
-          end
-        end
-      end
-    end
-
-    context "when not providing a partition by value" do
-      it "should construct a window function" do
-        query =
-          Tag
-          .define_window(:no_args).partition_by(order_by: { tag_number: :desc })
-          .select_window(:row_number, over: :no_args, as: :my_row)
-          .to_sql
-
-        expect(query).to eq("SELECT (ROW_NUMBER() OVER no_args) AS \"my_row\" FROM \"tags\" WINDOW no_args AS (ORDER BY tag_number DESC)")
-      end
-    end
-  end
-end

data/spec/sql_inspections/with_cte_sql_spec.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Active Record WITH CTE tables" do
-  let(:with_personal_query) { /WITH.+personal_id_one.+AS \(SELECT.+users.+FROM.+WHERE.+users.+personal_id.+ = 1\)/ }
-
-  it "should contain WITH statement that creates the CTE table" do
-    query = User.with(personal_id_one: User.where(personal_id: 1))
-                .joins("JOIN personal_id_one ON personal_id_one.id = users.id")
-                .to_sql
-    expect(query).to match_regex(with_personal_query)
-  end
-
-  it "will maintain the CTE table when merging" do
-    query = User.all
-                .merge(User.with(personal_id_one: User.where(personal_id: 1)))
-                .joins("JOIN personal_id_one ON personal_id_one.id = users.id")
-                .to_sql
-
-    expect(query).to match_regex(with_personal_query)
-  end
-
-  it "will pipe Children CTE's into the Parent relation" do
-    personal_id_one_query = User.where(personal_id: 1)
-    personal_id_two_query = User.where(personal_id: 2)
-
-    sub_query       = personal_id_two_query.with(personal_id_one: personal_id_one_query)
-    query           = User.all.with(personal_id_two: sub_query)
-    expected_order  = User.with(
-      personal_id_one: personal_id_one_query,
-      personal_id_two: personal_id_two_query
-    )
-
-    expect(query.to_sql).to eq(expected_order.to_sql)
-  end
-
-  context "when multiple CTE's" do
-    let(:chained_with) do
-      User.with(personal_id_one: User.where(personal_id: 1))
-          .with(personal_id_two: User.where(personal_id: 2))
-          .joins("JOIN personal_id_one ON personal_id_one.id = users.id")
-          .joins("JOIN personal_id_two ON personal_id_two.id = users.id")
-          .to_sql
-    end
-
-    let(:with_arguments) do
-      User.with(personal_id_one: User.where(personal_id: 1), personal_id_two: User.where(personal_id: 2))
-          .joins("JOIN personal_id_one ON personal_id_one.id = users.id")
-          .joins("JOIN personal_id_two ON personal_id_two.id = users.id")
-          .to_sql
-    end
-
-    it "Should only contain a single WITH statement" do
-      expect(with_arguments.scan(/WITH/).count).to eq(1)
-      expect(with_arguments.scan(/AS/).count).to eq(2)
-    end
-
-    it "Should only contain a single WITH statement when chaining" do
-      expect(chained_with.scan(/WITH/).count).to eq(1)
-      expect(chained_with.scan(/AS/).count).to eq(2)
-    end
-  end
-
-  context "when chaining the recursive method" do
-    let(:with_recursive_personal_query) do
-      /WITH.+RECURSIVE.+personal_id_one.+AS \(SELECT.+users.+FROM.+WHERE.+users.+personal_id.+ = 1\)/
-    end
-
-    let(:with_recursive) do
-      User.with
-          .recursive(personal_id_one: User.where(personal_id: 1))
-          .joins("JOIN personal_id_one ON personal_id_one.id = users.id")
-          .to_sql
-    end
-
-    it "generates an expression with recursive" do
-      query = User.with
-                  .recursive(personal_id_one: User.where(personal_id: 1))
-                  .joins("JOIN personal_id_one ON personal_id_one.id = users.id")
-                  .to_sql
-
-      expect(query).to match_regex(with_recursive_personal_query)
-    end
-
-    it "will maintain the CTE table when merging" do
-      sub_query = User.with.recursive(personal_id_one: User.where(personal_id: 1))
-      query     = User.merge(sub_query)
-                      .joins("JOIN personal_id_one ON personal_id_one.id = users.id")
-                      .to_sql
-
-      expect(query).to match_regex(with_recursive_personal_query)
-    end
-  end
-end

data/spec/support/database_cleaner.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require "database_cleaner"
-
-DatabaseCleaner.strategy = :transaction
-
-RSpec.configure do |config|
-  config.before do
-    DatabaseCleaner.start
-  end
-
-  config.after do
-    DatabaseCleaner.clean
-  end
-end

data/spec/support/models.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-class ApplicationRecord < ActiveRecord::Base
-  self.abstract_class = true
-end
-
-class User < ApplicationRecord
-  has_many :groups_users, class_name: "GroupsUser"
-  has_many :groups, through: :groups_users, dependent: :destroy
-  has_many :hm_tags, class_name: "Tag"
-  has_one :profile_l, class_name: "ProfileL"
-  has_one :profile_r, class_name: "ProfileR"
-  # attributes
-  # t.string   "tags",         array: true
-  # t.integer  "number",       default: 0
-  # t.string   "name"
-  # t.integer  "personal_id"
-  # t.hstore   "data"
-  # t.jsonb    "jsonb_data"
-  # t.inet     "ip"
-  # t.cidr     "subnet"
-  #
-end
-
-class StiRecord < ApplicationRecord
-  # t.string "type"
-end
-
-class AdminSti < StiRecord; end
-
-module Namespaced
-  def self.table_name_prefix
-    "namespaced_"
-  end
-
-  class Record < ApplicationRecord
-    # attributes
-    # t.inet :ip
-    # t.cidr :subnet
-    #
-  end
-end
-
-class Tag < ApplicationRecord
-  belongs_to :user
-  # attributes: tag_number
-end
-
-class ProfileL < ApplicationRecord
-  belongs_to :user
-  has_one :version, as: :versionable, class_name: "VersionControl"
-  # attributes
-  # t.integer :likes
-  #
-end
-
-class ProfileR < ApplicationRecord
-  belongs_to :user
-  has_one :version, as: :versionable, class_name: "VersionControl"
-  # attributes
-  # t.integer :dislikes
-  #
-end
-
-class VersionControl < ApplicationRecord
-  belongs_to :versionable, polymorphic: true, optional: false
-  # attributes
-  # t.jsonb :source, default: {}, null: false
-  #
-end
-
-class Group < ApplicationRecord
-  has_many :groups_users, class_name: "GroupsUser"
-  has_many :users, through: :groups_users, dependent: :destroy
-end
-
-class GroupsUser < ApplicationRecord
-  belongs_to :user
-  belongs_to :group
-end