dbee-active_record 2.0.4 → 2.2.0

data/spec/dbee/providers/active_record_provider/expression_builder_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+require 'db_helper'
+
+describe Dbee::Providers::ActiveRecordProvider::ExpressionBuilder do
+  let(:schema)      { Dbee::Schema.new(models['Patients']) }
+  let(:alias_maker) { Dbee::Providers::ActiveRecordProvider::SafeAliasMaker.new }
+
+  let(:empty_query) { Dbee::Query.make(from: :patients) }
+
+  let(:id_and_average_query) do
+    Dbee::Query.make(
+      from: :patients,
+      fields: [
+        {
+          key_path: :id,
+          display: 'ID #'
+        },
+        {
+          key_path: 'patient_payments.amount',
+          display: 'Ave Payment',
+          aggregator: :ave
+        }
+      ],
+      sorters: [
+        {
+          key_path: :id
+        }
+      ],
+      filters: [
+        {
+          key_path: :id,
+          value: 123
+        }
+      ]
+    )
+  end
+
+  let(:first_and_count_query) do
+    Dbee::Query.make(
+      from: :patients,
+      fields: [
+        {
+          key_path: :first,
+          display: 'First Name'
+        },
+        {
+          key_path: 'patient_payments.amount',
+          display: 'Number of Payments',
+          aggregator: :count
+        }
+      ]
+    )
+  end
+
+  subject { described_class.new(schema, alias_maker, alias_maker) }
+
+  before(:all) do
+    connect_to_db(:sqlite)
+  end
+
+  describe '#to_sql' do
+    specify 'when called with no fields, then called with fields removes star select' do
+      expect(subject.to_sql(empty_query)).to include('*')
+      expect(subject.to_sql(id_and_average_query)).not_to include('*')
+    end
+
+    context 'with aggregation' do
+      it 'generates the same sql when called multiple times' do
+        first_sql  = subject.to_sql(id_and_average_query)
+        second_sql = subject.to_sql(id_and_average_query)
+
+        expect(first_sql).to eq(second_sql)
+
+        third_sql  = subject.to_sql(first_and_count_query)
+        fourth_sql = subject.to_sql(first_and_count_query)
+
+        expect(third_sql).to eq(fourth_sql)
+      end
+    end
+  end
+end

data/spec/dbee/providers/active_record_provider/makers/where_spec.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+require 'db_helper'
+
+# rubocop:disable Layout/LineLength
+# Disable the line length cop beause there are some lengthy 'expected' SQL strings in spec which
+# cannot be shortened.
+describe Dbee::Providers::ActiveRecordProvider::Makers::Where do
+  before(:all) { connect_to_db(:sqlite) }
+
+  let(:subject) { described_class.instance }
+  let(:column) { Arel::Table.new(:test)[:foo] }
+
+  describe 'equals' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" = 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[("test"."foo" IS NULL OR "test"."foo" IN ('a', 'c'))]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: %w[a b c])
+      expect(subject.make(filter, column).to_sql).to eq %q["test"."foo" IN ('a', 'b', 'c')]
+    end
+  end
+
+  describe 'not equals' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" != 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NOT NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[("test"."foo" IS NOT NULL OR "test"."foo" NOT IN ('a', 'c'))]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: %w[a b c])
+      expect(subject.make(filter, column).to_sql).to eq %q["test"."foo" NOT IN ('a', 'b', 'c')]
+    end
+  end
+
+  describe 'contains' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" LIKE '%bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" LIKE '%a%') OR "test"."foo" LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" LIKE '%a%' OR "test"."foo" LIKE '%b%') OR "test"."foo" LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'not contains' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" NOT LIKE '%bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NOT NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NOT NULL OR "test"."foo" NOT LIKE '%a%') OR "test"."foo" NOT LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" NOT LIKE '%a%' OR "test"."foo" NOT LIKE '%b%') OR "test"."foo" NOT LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'starts with' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" LIKE 'bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" LIKE 'a%') OR "test"."foo" LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" LIKE 'a%' OR "test"."foo" LIKE 'b%') OR "test"."foo" LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'not start with' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" NOT LIKE 'bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NOT NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NOT NULL OR "test"."foo" NOT LIKE 'a%') OR "test"."foo" NOT LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" NOT LIKE 'a%' OR "test"."foo" NOT LIKE 'b%') OR "test"."foo" NOT LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'greater than' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" > 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" > 'a') OR "test"."foo" > 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" > 'a' OR "test"."foo" > 'b') OR "test"."foo" > 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'greater than or equal to' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" >= 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" >= 'a') OR "test"."foo" >= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" >= 'a' OR "test"."foo" >= 'b') OR "test"."foo" >= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'less than' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" < 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" < 'a') OR "test"."foo" < 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" < 'a' OR "test"."foo" < 'b') OR "test"."foo" < 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'less than or equal to' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" <= 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" <= 'a') OR "test"."foo" <= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" <= 'a' OR "test"."foo" <= 'b') OR "test"."foo" <= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+end
+# rubocop:enable Layout/LineLength

data/spec/dbee/providers/active_record_provider_spec.rb

@@ -11,22 +11,19 @@ require 'spec_helper'
 require 'db_helper'
 
 describe Dbee::Providers::ActiveRecordProvider do
-  let(:models) { yaml_fixture('models.yaml') }
-
   describe '#sql' do
     before(:all) do
       connect_to_db(:sqlite)
     end
 
     it 'errors when joining tables with no constraints' do
-      model_hash = {
-        name: :users,
-        models: [
-          { name: :logins }
-        ]
+      schema_hash = {
+        users: { relationships: { logins: nil } },
+        logins: nil
       }
 
       query_hash = {
+        from: :users,
         fields: [
           { key_path: 'id' },
           { key_path: 'logins.id' }
@@ -34,11 +31,11 @@ describe Dbee::Providers::ActiveRecordProvider do
       }
 
       query = Dbee::Query.make(query_hash)
-      model = Dbee::Model.make(model_hash)
+      schema = Dbee::Schema.new(schema_hash)
 
       error_class = Dbee::Providers::ActiveRecordProvider::ExpressionBuilder::MissingConstraintError
 
-      expect { described_class.new.sql(model, query) }.to raise_error(error_class)
+      expect { described_class.new.sql(schema, query) }.to raise_error(error_class)
     end
   end
 
@@ -57,12 +54,13 @@ describe Dbee::Providers::ActiveRecordProvider do
               yaml_fixture_files('active_record_snapshots').each_pair do |filename, snapshot|
                 specify File.basename(filename) do
                   model_name = snapshot['model_name']
+
                   query = Dbee::Query.make(snapshot['query'])
-                  model = Dbee::Model.make(models[model_name])
+                  schema = Dbee::Schema.new(models[model_name])
 
                   expected_5_sql  = snapshot[key].to_s.chomp.tr("\n", ' ')
                   expected_6_sql  = expected_5_sql.gsub('  ', ' ').gsub("'t'", '1').gsub("'f'", '0')
-                  actual_sql      = described_class.new(readable: readable).sql(model, query)
+                  actual_sql      = described_class.new(readable: readable).sql(schema, query)
 
                   error_msg = <<~ERROR_MSG
                     Expected 5 SQL: #{expected_5_sql}
@@ -79,7 +77,7 @@ describe Dbee::Providers::ActiveRecordProvider do
       end
     end
 
-    context 'Executing SQL' do
+    context 'Shallow SQL Execution' do
       %w[sqlite].each do |dbms|
         context dbms do
           before(:all) do
@@ -95,9 +93,9 @@ describe Dbee::Providers::ActiveRecordProvider do
                 specify File.basename(filename) do
                   model_name = snapshot['model_name']
                   query = Dbee::Query.make(snapshot['query'])
-                  model = Dbee::Model.make(models[model_name])
+                  schema = Dbee::Schema.new(models[model_name])
 
-                  sql = described_class.new(readable: readable).sql(model, query)
+                  sql = described_class.new(readable: readable).sql(schema, query)
 
                   expect { ActiveRecord::Base.connection.execute(sql) }.to_not raise_error
                 end
@@ -108,4 +106,104 @@ describe Dbee::Providers::ActiveRecordProvider do
       end
     end
   end
+
+  describe 'Deep SQL execution' do
+    before(:all) do
+      connect_to_db(:sqlite)
+      load_schema
+      load_data
+    end
+
+    describe 'pivoting' do
+      let(:snapshot_path) do
+        %w[
+          spec
+          fixtures
+          active_record_snapshots
+          two_table_query_with_pivoting.yaml
+        ]
+      end
+
+      let(:snapshot) { yaml_file_read(*snapshot_path) }
+      let(:query)    { Dbee::Query.make(snapshot['query']) }
+      let(:schema)   { Dbee::Schema.new(models['Patients']) }
+
+      it 'pivots table rows into columns' do
+        sql = described_class.new.sql(schema, query)
+
+        results = ActiveRecord::Base.connection.execute(sql)
+
+        expect(results[0]).to include(
+          'First Name' => 'Bozo',
+          'Date of Birth' => '1904-04-04',
+          'Drivers License #' => '82-54-hut-hut-hike!',
+          'Demographic Notes' => 'The patient is funny!',
+          'Contact Notes' => 'Do not call this patient at night!'
+        )
+
+        expect(results[1]).to include(
+          'First Name' => 'Frank',
+          'Date of Birth' => nil,
+          'Drivers License #' => nil,
+          'Demographic Notes' => nil,
+          'Contact Notes' => nil
+        )
+
+        expect(results[2]).to include(
+          'First Name' => 'Bugs',
+          'Date of Birth' => '2040-01-01',
+          'Drivers License #' => nil,
+          'Demographic Notes' => nil,
+          'Contact Notes' => 'Call anytime!!'
+        )
+      end
+    end
+
+    describe 'aggregation' do
+      let(:snapshot_path) do
+        %w[
+          spec
+          fixtures
+          active_record_snapshots
+          two_table_query_with_aggregation.yaml
+        ]
+      end
+
+      let(:snapshot) { yaml_file_read(*snapshot_path) }
+      let(:query)    { Dbee::Query.make(snapshot['query']) }
+      let(:schema) { Dbee::Schema.new(models['Patients']) }
+
+      it 'executes correct SQL aggregate functions' do
+        sql     = described_class.new.sql(schema, query)
+        results = ActiveRecord::Base.connection.execute(sql)
+
+        expect(results[0]).to include(
+          'First Name' => 'Bozo',
+          'Ave Payment' => 10,
+          'Number of Payments' => 3,
+          'Max Payment' => 15,
+          'Min Payment' => 5,
+          'Total Paid' => 30
+        )
+
+        expect(results[1]).to include(
+          'First Name' => 'Frank',
+          'Ave Payment' => 100,
+          'Number of Payments' => 2,
+          'Max Payment' => 150,
+          'Min Payment' => 50,
+          'Total Paid' => 200
+        )
+
+        expect(results[2]).to include(
+          'First Name' => 'Bugs',
+          'Ave Payment' => nil,
+          'Number of Payments' => 0,
+          'Max Payment' => nil,
+          'Min Payment' => nil,
+          'Total Paid' => nil
+        )
+      end
+    end
+  end
 end