directiverecord 0.1.0

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+require_relative "test_helper/coverage"
+
+require "minitest/autorun"
+require "mocha/setup"
+
+require "bundler"
+Bundler.require :default, :development
+
+require_relative "application/boot"
+
+def project_file(path)
+  File.expand_path "../../#{path}", __FILE__
+end
+
+def strip(sql)
+  sql.strip.gsub(/^\s+/m, "")
+end

data/test/test_helper/coverage.rb

@@ -0,0 +1,13 @@
+if Dir.pwd == File.expand_path("../../..", __FILE__)
+
+require "simplecov"
+
+SimpleCov.coverage_dir "test/coverage"
+SimpleCov.start do
+  add_group "DirectiveRecord", "lib"
+  add_group "App models", "app/models"
+  add_group "Test suite", "test"
+  add_filter "boot.rb"
+end
+
+end

data/test/unit/gem_ext/active_record/test_base.rb

@@ -0,0 +1,30 @@
+require_relative "../../../test_helper"
+
+module Unit
+  module GemExt
+    module ActiveRecord
+      class TestBase < MiniTest::Test
+
+        describe ::ActiveRecord::Base do
+          describe ".to_qry" do
+            it "initiates a DirectiveRecord::Query instance and returns the query SQL" do
+              query = mock
+              query.expects(:to_sql).with(:select => "city").returns("SELECT city FROM offices")
+              DirectiveRecord::Query.expects(:new).with(Office).returns(query)
+              assert_equal "SELECT city FROM offices", Office.to_qry(:select => "city")
+            end
+          end
+
+          describe ".qry" do
+            it "selects rows with the generated query" do
+              Office.expects(:to_qry).with("city").returns("SELECT city FROM offices")
+              Office.connection.expects(:select_rows).with("SELECT city FROM offices").returns(%w(NYC))
+              assert_equal %w(NYC), Office.qry("city")
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/test/unit/gem_ext/active_record/test_relation.rb

@@ -0,0 +1,42 @@
+require_relative "../../../test_helper"
+
+module Unit
+  module GemExt
+    module ActiveRecord
+      class TestRelation < MiniTest::Test
+
+        describe ::ActiveRecord::Relation do
+          before do
+            @relation = Office.where(:id => 1)
+          end
+
+          describe "#qry_options" do
+            it "initiates a DirectiveRecord::Relation instance and returns the query options" do
+              relation = mock
+              relation.expects(:qry_options).returns(:where => "id = 1")
+              DirectiveRecord::Relation.expects(:new).with(@relation).returns(relation)
+              assert_equal({:where => "id = 1"}, @relation.qry_options)
+            end
+          end
+
+          describe "#to_qry" do
+            it "delegates to its klass with qry_options" do
+              @relation.expects(:qry_options).with("city").returns(:select => "city", :where => ["id = 1"])
+              Office.expects(:to_qry).with(:select => "city", :where => ["id = 1"]).returns("SELECT city FROM offices WHERE id = 1")
+              assert_equal "SELECT city FROM offices WHERE id = 1", @relation.to_qry("city")
+            end
+          end
+
+          describe "#qry" do
+            it "delegates to its klass with qry_options" do
+              @relation.expects(:qry_options).with("city").returns(:select => "city", :where => ["id = 1"])
+              Office.expects(:qry).with(:select => "city", :where => ["id = 1"]).returns(%w(NYC))
+              assert_equal %w(NYC), @relation.qry("city")
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/test/unit/query/test_monetdb.rb

@@ -0,0 +1,27 @@
+require_relative "../../test_helper"
+
+module Unit
+  module Query
+    class TestMonetDB < MiniTest::Test
+
+      describe DirectiveRecord::Query::MonetDB do
+        before do
+          DirectiveRecord::Query.expects(:class_for).returns(DirectiveRecord::Query::MonetDB).at_least_once
+        end
+
+        it "generates the expected SQL" do
+          assert_equal(
+            strip(
+              %Q{
+                SELECT o.id, o.city
+                FROM offices o
+              }
+            ),
+            Office.to_qry("id, city")
+          )
+        end
+      end
+
+    end
+  end
+end

data/test/unit/query/test_mysql.rb

@@ -0,0 +1,238 @@
+require_relative "../../test_helper"
+
+module Unit
+  module Query
+    class TestMySQL < MiniTest::Test
+
+      describe DirectiveRecord::Query::MySQL do
+        before do
+          DirectiveRecord::Query.expects(:class_for).returns(DirectiveRecord::Query::MySQL).at_least_once
+        end
+
+        it "generates the expected SQL" do
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `o`.id, `o`.city
+                FROM offices `o`
+              }
+            ),
+            Office.to_qry("id, city")
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `e`.*
+                FROM employees `e`
+                WHERE (`e`.office_id = 1) AND (`e`.first_name LIKE '%y')
+              }
+            ),
+            Employee.where(:office_id => 1).where(Employee.arel_table[:first_name].matches("%y")).to_qry
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `e`.*
+                FROM employees `e`
+                WHERE ((`e`.office_id = 1) AND (`e`.first_name LIKE '%y'))
+              }
+            ),
+            Employee.where("(office_id = 1) AND (first_name LIKE '%y')").to_qry
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `c`.id, `c`.name, COUNT(`orders`.id) AS order_count, GROUP_CONCAT(DISTINCT `tags`.name) AS tags
+                FROM customers `c`
+                LEFT JOIN orders `orders` ON `orders`.customer_id = `c`.id
+                LEFT JOIN customers_tags `tags_bridge_table` ON `tags_bridge_table`.customer_id = `c`.id
+                LEFT JOIN tags `tags` ON `tags`.id = `tags_bridge_table`.tag_id
+                GROUP BY `c`.id
+                ORDER BY COUNT(DISTINCT `tags`.id) DESC
+                LIMIT 5
+              }
+            ),
+            Customer.to_qry("id, name, COUNT(orders.id) AS order_count, GROUP_CONCAT(DISTINCT tags.name) AS tags", :group_by => "id", :order_by => "COUNT(DISTINCT tags.id) DESC", :limit => 5)
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `c`.*
+                FROM customers `c`
+                LEFT JOIN customers_tags `tags_bridge_table` ON `tags_bridge_table`.customer_id = `c`.id
+                LEFT JOIN tags `tags` ON `tags`.id = `tags_bridge_table`.tag_id
+                WHERE (`tags`.name LIKE '%gifts%')
+              }
+            ),
+            Customer.where("tags.name LIKE ?", "%gifts%").to_qry
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `tags`.*
+                FROM customers `c`
+                LEFT JOIN customers_tags `tags_bridge_table` ON `tags_bridge_table`.customer_id = `c`.id
+                LEFT JOIN tags `tags` ON `tags`.id = `tags_bridge_table`.tag_id
+                WHERE (`tags`.name LIKE '%gifts%')
+                GROUP BY `tags`.id
+                ORDER BY `tags`.id
+              }
+            ),
+            Customer.where("tags.name LIKE ?", "%gifts%").group("tags.id").to_qry("tags.*")
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `c`.id, `c`.name, COUNT(`orders`.id) AS order_count
+                FROM customers `c`
+                LEFT JOIN orders `orders` ON `orders`.customer_id = `c`.id
+                GROUP BY `c`.id
+                HAVING (order_count > 3)
+                ORDER BY `c`.id
+              }
+            ),
+            Customer.to_qry("id, name, COUNT(orders.id) AS order_count", :where => "order_count > 3", :group_by => "id")
+          )
+
+          $default_office_scope = {:id => [1, 3, 6]}
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `o`.id AS c1, `o`.city AS c2
+                FROM offices `o`
+                WHERE (`o`.id IN (1, 3, 6))
+              }
+            ),
+            Office.to_qry("id", "city", :numerize_aliases => true)
+          )
+
+          $default_office_scope = nil
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `o`.id AS c1, `o`.city AS c2
+                FROM offices `o`
+              }
+            ),
+            Office.to_qry("id", "city", :numerize_aliases => true)
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `c`.id, `c`.name, MAX(`orders`.order_date) AS `max:orders.order_date`
+                FROM customers `c`
+                LEFT JOIN orders `orders` ON `orders`.customer_id = `c`.id
+              }
+            ),
+            Customer.to_qry("id", "name", "orders.order_date", :aggregates => {"orders.order_date" => :max})
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `c`.id, `c`.name, MAX(`orders`.order_date) AS `max:orders.order_date`
+                FROM customers `c`
+                LEFT JOIN orders `orders` ON `orders`.customer_id = `c`.id
+                ORDER BY MAX(`orders`.order_date)
+              }
+            ),
+            Customer.to_qry("id", "name", "orders.order_date", :aggregates => {"orders.order_date" => :max}, :order_by => "orders.order_date")
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT ROUND(SUM(`od`.price_each), 2) AS `sum:price_each`
+                FROM order_details `od`
+                GROUP BY NULL
+              }
+            ),
+            OrderDetail.to_qry("price_each", :aggregates => {"price_each" => :sum}, :group_by => :all)
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT ROUND(SUM(`od`.price_each), 2) AS `sum:price_each`
+                FROM order_details `od`
+                GROUP BY `od`.order_id
+                ORDER BY `od`.order_id
+              }
+            ),
+            OrderDetail.to_qry("price_each", :aggregates => {"price_each" => :sum}, :group_by => "order_id")
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `order`.id AS c1, ROUND(SUM(`od`.price_each), 2) AS c2
+                FROM order_details `od`
+                LEFT JOIN orders `order` ON `order`.id = `od`.order_id
+                GROUP BY c1
+                ORDER BY c1
+              }
+            ),
+            OrderDetail.to_qry("order.id", "price_each", :aggregates => {"price_each" => :sum}, :group_by => "order.id", :numerize_aliases => true)
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `e`.*
+                FROM employees `e`
+                WHERE (`e`.first_name LIKE '%y')
+              }
+            ),
+            Employee.where(["first_name LIKE ?", "%y"]).to_qry
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `e`.id
+                FROM employees `e`
+                LEFT JOIN offices `office` ON `office`.id = `e`.office_id
+                ORDER BY `office`.city, `e`.last_name, `e`.first_name
+              }
+            ),
+            Employee.to_qry("id", :order_by => "office.city, last_name, first_name")
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `e`.id, `office`.city
+                FROM employees `e`
+                LEFT JOIN offices `office` ON `office`.id = `e`.office_id
+                WHERE (`e`.id IN (1143, 1076, 1165, 1002, 1056, 1166, 0))
+                ORDER BY `office`.city, `e`.last_name, `e`.first_name
+              }
+            ),
+            Employee.to_qry("id", "office.city", :where => "office_id = 1", :order_by => "office.city, last_name, first_name")
+          )
+
+          assert_equal(
+            strip(
+              %Q{
+                SELECT `o`.*
+                FROM offices `o`
+                WHERE (`o`.country = 'USA')
+              }
+            ),
+            Office.usa.to_qry
+          )
+        end
+      end
+
+    end
+  end
+end

data/test/unit/query/test_sql.rb

@@ -0,0 +1,46 @@
+require_relative "../../test_helper"
+
+module Unit
+  module Query
+    class TestSQL < MiniTest::Test
+
+      describe DirectiveRecord::Query::SQL do
+        before do
+          @base = mock
+          @directive_query = DirectiveRecord::Query::SQL.new(@base)
+        end
+
+        describe "#initialize" do
+          it "stores the passed base class as an instance variable" do
+            assert_equal @base, @directive_query.instance_variable_get(:@base)
+          end
+        end
+
+        describe "#path_delimiter" do
+          it "raises an NotImplementedError" do
+            assert_raises NotImplementedError do
+              @directive_query.send :path_delimiter
+            end
+          end
+        end
+
+        describe "#aggregate_delimiter" do
+          it "raises an NotImplementedError" do
+            assert_raises NotImplementedError do
+              @directive_query.send :aggregate_delimiter
+            end
+          end
+        end
+
+        describe "#group_by_all_sql" do
+          it "raises an NotImplementedError" do
+            assert_raises NotImplementedError do
+              @directive_query.send :group_by_all_sql
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/test/unit/test_directive_record.rb

@@ -0,0 +1,15 @@
+require_relative "../test_helper"
+
+module Unit
+  class TestDirectiveRecord < MiniTest::Test
+
+    describe DirectiveRecord do
+      it "has the current version" do
+        version = File.read(project_file("VERSION")).strip
+        assert_equal version, DirectiveRecord::VERSION
+        assert File.read(project_file("CHANGELOG.rdoc")).include?("Version #{version} ")
+      end
+    end
+
+  end
+end

data/test/unit/test_query.rb

@@ -0,0 +1,40 @@
+require_relative "../test_helper"
+
+module Unit
+  class TestQuery < MiniTest::Test
+
+    describe DirectiveRecord::Query do
+      describe ".new" do
+        it "returns the appropriate query instance" do
+          instance = mock
+          instance.expects(:new).with(Office).returns("SELECT * FROM offices")
+          DirectiveRecord::Query.expects(:class_for).with("activerecord::connectionadapters::mysql2adapter").returns(instance)
+          assert_equal "SELECT * FROM offices", DirectiveRecord::Query.new(Office)
+        end
+      end
+
+      describe ".class_for" do
+        describe "when MySQL" do
+          it "returns the DirectiveRecord::Query::MySQL class" do
+            assert_equal DirectiveRecord::Query::MySQL, DirectiveRecord::Query.send(:class_for, "activerecord::connectionadapters::mysql2adapter")
+          end
+        end
+
+        describe "when MonetDB" do
+          it "returns the DirectiveRecord::Query::MonetDB class" do
+            assert_equal DirectiveRecord::Query::MonetDB, DirectiveRecord::Query.send(:class_for, "monetdb::connection")
+          end
+        end
+
+        describe "when else" do
+          it "raises a NotImplementedError" do
+            assert_raises NotImplementedError do
+              DirectiveRecord::Query.send(:class_for, "foobar::connection")
+            end
+          end
+        end
+      end
+    end
+
+  end
+end