data_task 0.0.2

data/test/postgresql_spec.rb

@@ -0,0 +1,249 @@
+require_relative './helper.rb'
+require 'data_task/adapters/postgres'
+
+module Rake
+  module DataTask
+
+    describe Postgres do
+
+      right_schema = "test_schema_1"
+      wrong_schema = "test_schema_2"
+      test_table = "test_table"
+      test_view = "test_view"
+      test_role = "test_role"
+
+      test_table_right_schema = "#{right_schema}.#{test_table}"
+      test_table_wrong_schema = "#{wrong_schema}.#{test_table}"
+
+      test_view_right_schema = "#{right_schema}.#{test_view}"
+      test_view_wrong_schema = "#{wrong_schema}.#{test_view}"
+
+      around do |test|
+        @adapter = get_adapter
+        if !@adapter.kind_of?(Rake::DataTask::Postgres)
+          skip("Using adapter #{@adapter}, so skipping #{self.class} tests.")
+        end
+
+        @adapter.with_transaction_rollback do
+          @adapter.execute <<-EOSQL
+            create schema #{right_schema};
+            create schema #{wrong_schema};
+          EOSQL
+          test.call
+          @adapter.execute <<-EOSQL
+            drop schema #{right_schema} cascade;
+            drop schema #{wrong_schema} cascade;
+          EOSQL
+        end
+      end
+
+      it "returns the current user name when called to" do
+        @adapter.execute "create role #{test_role}"
+        @adapter.with_role(test_role) do
+          @adapter.send(:current_user).must_equal test_role
+        end
+      end
+
+      it "returns the current search path when called to" do
+        @adapter.execute "set search_path to #{right_schema}, public"
+        @adapter.send(:search_path).must_equal [right_schema, 'public']
+      end
+
+      it "resets the search path after exiting a with_search_path block" do
+        @adapter.execute "set search_path to #{right_schema}, public"
+        @adapter.with_search_path([wrong_schema,'public']) do
+          @adapter.send(:search_path).must_equal [wrong_schema, 'public']
+        end
+        @adapter.send(:search_path).must_equal [right_schema, 'public']
+      end
+
+      it "returns the first schema in the search path that contains a table when called to" do
+        @adapter.execute "create table #{right_schema}.#{test_table} (var1 integer)"
+        @adapter.execute "set search_path to #{wrong_schema}, #{right_schema}, 'public'"
+        @adapter.send(:first_schema_for, test_table).must_equal right_schema
+      end
+
+      it "finds a table when it exists in the right schema" do
+        @adapter.execute "create table #{test_table_right_schema} (var1 integer)"
+        @adapter.table_exists?(test_table_right_schema).must_equal true
+      end
+
+      it "does not find a table when it does not exist in the right schema" do
+        @adapter.table_exists?(test_table_right_schema).must_equal false
+      end
+
+      it "does not find a table when it exists in the wrong schema" do
+        @adapter.execute "create table #{test_table_wrong_schema} (var1 integer)"
+        @adapter.table_exists?(test_table_right_schema).must_equal false
+      end
+
+      it "creates a table in the right schema when called to" do
+        @adapter.with_search_path([right_schema,'public']) do
+          @adapter.with_tracking do
+            @adapter.create_table test_table_right_schema, nil, '(var1 text)'
+            @adapter.table_exists?(test_table_right_schema).must_equal true
+          end
+        end
+      end
+
+      it "drops a table in the right schema when called to" do
+        @adapter.with_search_path([right_schema,'public']) do
+          @adapter.with_tracking do
+
+            @adapter.execute "create table #{test_table_right_schema} (var1 text)"
+            @adapter.execute "create table #{test_table_wrong_schema} (var1 text)"
+            @adapter.drop_table test_table_right_schema
+            @adapter.table_exists?(test_table_right_schema).must_equal false
+            @adapter.table_exists?(test_table_wrong_schema).must_equal true
+
+          end
+        end
+      end
+
+      it "creates a view in the right schema when called to" do
+        @adapter.with_search_path([right_schema,'public']) do
+          @adapter.with_tracking do
+
+            @adapter.create_view test_view_right_schema, "select * from information_schema.tables limit 0"
+            @adapter.view_exists?(test_view_right_schema).must_equal true
+
+          end
+        end
+      end
+
+      it "drops a view in the right schema when called to" do
+        @adapter.with_search_path([right_schema,'public']) do
+          @adapter.with_tracking do
+
+            @adapter.create_view test_view_right_schema, "select * from information_schema.tables limit 0"
+            @adapter.drop_view test_view_right_schema
+            @adapter.view_exists?(test_view_right_schema).must_equal false
+
+          end
+        end
+      end
+
+      it "updates the tracking table in the right schema when it creates a table" do
+        @adapter.with_search_path([right_schema,'public']) do
+          @adapter.with_tracking do
+
+            @adapter.create_table test_table_right_schema, nil, '(var1 integer)'
+            tracked_create = Sql.get_single_int(
+              @adapter.execute <<-EOSQL
+                select 1 from #{right_schema}.#{Db::TABLE_TRACKER_NAME} 
+                where 
+                  relation_name = '#{test_table}' and
+                  relation_type = '#{@adapter.relation_type_values[:table]}' and
+                  operation = '#{@adapter.operation_values[:create]}'
+              EOSQL
+            )
+            tracked_create.must_equal 1
+
+          end
+        end
+      end
+
+      it "updates the tracking table in the right schema when it drops a table" do
+        @adapter.with_search_path([right_schema,'public']) do
+          @adapter.with_tracking do
+
+            @adapter.create_table test_table_right_schema, nil, '(var1 text)'
+            @adapter.drop_table test_table_right_schema
+            still_tracking_table = Sql.get_single_int(
+              @adapter.execute <<-EOSQL
+                select 1 from #{right_schema}.#{Db::TABLE_TRACKER_NAME} 
+                where 
+                  relation_name = '#{test_table}' and
+                  relation_type = '#{@adapter.relation_type_values[:table]}'
+              EOSQL
+            )
+            still_tracking_table.must_be_nil
+
+          end
+        end
+      end
+
+      it "updates the tracking table in the right schema on insert to a tracked table" do
+        @adapter.with_search_path([right_schema,'public']) do
+          @adapter.with_tracking do
+
+            @adapter.create_table test_table_right_schema, nil, '(var1 text)'
+            @adapter.execute "insert into #{test_table_right_schema} values ('a')"
+            tracked_insert = Sql.get_single_int(
+              @adapter.execute <<-EOSQL
+                select 1 from #{right_schema}.#{Db::TABLE_TRACKER_NAME} 
+                where 
+                  relation_name = '#{test_table}' and
+                  relation_type = '#{@adapter.relation_type_values[:table]}' and
+                  operation = '#{@adapter.operation_values[:insert]}'
+              EOSQL
+            )
+            tracked_insert.must_equal 1
+
+          end
+        end
+      end
+
+      it "updates the tracking table in the right schema on update on a tracked table" do
+        @adapter.with_search_path([right_schema,'public']) do
+          @adapter.with_tracking do
+
+            @adapter.create_table test_table_right_schema, nil, '(var1 text, var2 text)'
+            @adapter.execute "insert into #{test_table_right_schema} values ('a', 'a')"
+            @adapter.execute "update #{test_table_right_schema} set var2 = 'b' where var1 = 'a'"
+
+            tracked_insert = Sql.get_single_int(
+              @adapter.execute <<-EOSQL
+                select 1 from #{right_schema}.#{Db::TABLE_TRACKER_NAME} 
+                where 
+                  relation_name = '#{test_table}' and
+                  relation_type = '#{@adapter.relation_type_values[:table]}' and
+                  operation = '#{@adapter.operation_values[:update]}'
+              EOSQL
+            )
+            tracked_insert.must_equal 1
+
+          end
+        end
+      end
+
+      it "updates the tracking table in the right schema on truncate of a tracked table" do
+        @adapter.with_search_path([right_schema,'public']) do
+          @adapter.with_tracking do
+
+            @adapter.create_table test_table_right_schema, nil, '(var1 text)'
+            @adapter.truncate_table test_table_right_schema
+            tracked_truncate = Sql.get_single_int(
+              @adapter.execute <<-EOSQL
+                select 1 from #{right_schema}.#{Db::TABLE_TRACKER_NAME} 
+                where 
+                  relation_name = '#{test_table}' and
+                  relation_type = '#{@adapter.relation_type_values[:table]}' and
+                  operation = '#{@adapter.operation_values[:truncate]}'
+              EOSQL
+            )
+            tracked_truncate.must_equal 1
+
+          end
+        end
+      end
+
+      it "says it is tracking tables after tracking is set up in the right schema" do
+        @adapter.with_search_path([right_schema,'public']) do
+          @adapter.tear_down_tracking
+          @adapter.set_up_tracking
+          (@adapter.tracking_tables?).must_equal true
+        end
+      end
+
+      it "says it is not tracking tables after tracking is torn down in the right schema" do
+        @adapter.with_search_path([right_schema,'public']) do
+          @adapter.tear_down_tracking
+          (@adapter.tracking_tables?).must_equal false
+        end
+      end
+
+    end
+
+  end
+end

data/test/sql_spec.rb

@@ -0,0 +1,46 @@
+require_relative './helper.rb'
+
+module Rake
+  module DataTask
+
+    describe Sql do
+
+      around do |test|
+        @adapter = get_adapter
+        @adapter.with_transaction_rollback do
+          test.call
+        end
+      end
+
+      context "when asked to parse a single value" do
+        it "raises an error if the results array contains more than one column" do
+          r = @adapter.execute('select 1,2')
+          lambda {Sql.parse_single_value(r)}.must_raise(TypeError)
+        end
+        it "raises an error if the results array contains more than one row" do
+          r = @adapter.execute('select 1 union all select 2')
+          lambda {Sql.parse_single_value(r)}.must_raise(TypeError)
+        end
+        it "returns nil if the results array contains no rows" do
+          r = @adapter.execute("select 1 where #{@adapter.falsey_value}")
+          Sql.parse_single_value(r).must_be_nil
+        end
+        it "returns nil if the results array contains a null value" do
+          r = @adapter.execute('select NULL')
+          Sql.parse_single_value(r).must_be_nil
+        end
+      end
+
+      context "when asked for a single integer" do
+        it "returns a single integer if the query result is a single value convertible to an integer" do
+          Sql.get_single_int(@adapter.execute('select 1')).must_be_kind_of Integer
+        end
+        it "raises an error if the query results in a single non-integer" do
+          lambda {Sql.get_single_int(@adapter.execute("select 'a'"))}.must_raise(ArgumentError)
+        end
+      end
+
+    end
+
+  end
+end

data/test/table_creation.rb

@@ -0,0 +1,34 @@
+module Rake
+  module DataTask
+    module DataCreation
+      OLDDATA = "old_data"
+      NEWDATA = "new_data"
+
+      def create_timed_data(adapter, old_data_name, *new_data_names)
+        old_data = Data.new(old_data_name, adapter)
+        return if (old_data.exists? &&
+          new_data_names.all? do |new_data_name|
+            new_data = Data.new(new_data_name, adapter)
+            new_data.exists? && new_data.mtime > old_data.mtime
+          end)
+        now = Time.now
+
+        create_data(adapter, old_data_name)
+        sleep(1.0)
+
+        new_data_names.each do |new_data_name|
+          create_data(adapter, new_data_name)
+        end
+      end
+
+      def create_data(adapter, name)
+        adapter.create_data name, nil, '(var1 integer, var2 integer)' unless adapter.data_exists?(name)
+        adapter.data_mtime(name)
+      end
+
+      def drop_data(adapter, name)
+        adapter.drop_data(name) rescue nil
+      end
+    end
+  end
+end

data/test/test_rake_table_task.rb

@@ -0,0 +1,207 @@
+require File.expand_path(
+  File.join(Gem::Specification.find_by_name('rake').gem_dir,'test/helper.rb'), __FILE__)
+require 'minitest/around/unit'
+require_relative './table_creation.rb'
+require_relative './helper.rb'
+
+module Rake
+  module DataTask
+
+    class TestRakeDataTask < Rake::TestCase
+      include Rake
+      include DataCreation
+
+      def around(&block)
+        @adapter = get_adapter
+        @adapter.with_transaction_rollback do
+          yield
+        end
+      end
+
+      def setup
+        super
+
+        Task.clear
+        @runs = Array.new
+      end
+
+      def test_data_need
+        @adapter.with_tracking do
+          name = "dummy"
+          data @adapter[name]
+          ttask = Task[name]
+
+          Data.drop(ttask.name) rescue nil
+          assert ttask.needed?, "data should be needed"
+
+          @adapter.create_data name, nil, '(var1 integer)'
+
+          assert_equal nil, ttask.prerequisites.collect{|n| Task[n].timestamp}.max
+          assert ! ttask.needed?, "data should not be needed"
+        end
+      end
+
+      def test_data_times_new_depends_on_old
+        @adapter.with_tracking do
+          create_timed_data(@adapter, OLDDATA, NEWDATA)
+
+          t1 = Rake.application.intern(DataTask, @adapter[NEWDATA]).enhance([@adapter[OLDDATA]])
+          t2 = Rake.application.intern(DataTask, @adapter[OLDDATA])
+          assert ! t2.needed?, "Should not need to build old data"
+          assert ! t1.needed?, "Should not need to rebuild new data because of old"
+        end
+      end
+
+      def test_data_times_new_depend_on_regular_task_timestamps
+        @adapter.with_tracking do
+          load_phony
+
+          name = "dummy"
+          task name
+
+          create_timed_data(@adapter, NEWDATA)
+
+          t1 = Rake.application.intern(DataTask, @adapter[NEWDATA]).enhance([name])
+
+          assert t1.needed?, "depending on non-data task uses Time.now"
+
+          task(name => :phony)
+
+          assert t1.needed?, "unless the non-data task has a timestamp"
+        end
+      end
+
+      def test_data_times_old_depends_on_new
+        @adapter.with_tracking do
+          create_timed_data(@adapter, OLDDATA, NEWDATA)
+
+          t1 = Rake.application.intern(DataTask, @adapter[OLDDATA]).enhance([@adapter[NEWDATA]])
+          t2 = Rake.application.intern(DataTask, @adapter[NEWDATA])
+          assert ! t2.needed?, "Should not need to build new data"
+          preq_stamp = t1.prerequisites.collect{|t| Task[t].timestamp}.max
+          assert_equal t2.timestamp, preq_stamp
+          assert t1.timestamp < preq_stamp, "T1 should be older"
+          assert t1.needed?, "Should need to rebuild old data because of new"
+        end
+      end
+
+      def test_data_depends_on_task_depend_on_data
+        @adapter.with_tracking do
+          create_timed_data(@adapter, OLDDATA, NEWDATA)
+
+          data @adapter[NEWDATA] => [:obj] do |t| @runs << t.name end
+          task :obj => [OLDDATA] do |t| @runs << t.name end
+          data @adapter[OLDDATA] do |t| @runs << t.name end
+
+          Task[:obj].invoke
+          Task[NEWDATA].invoke
+          assert @runs.include?(NEWDATA)
+        end
+      end
+
+      def test_existing_data_depends_on_non_existing_data
+        @adapter.with_tracking do
+          @ran = false
+
+          create_data(@adapter, OLDDATA)
+          drop_data(@adapter, NEWDATA)
+          data @adapter[NEWDATA] do
+            @ran = true
+          end
+
+          data @adapter[OLDDATA] => NEWDATA
+
+          Task[OLDDATA].invoke
+
+          assert @ran
+        end
+      end
+
+      def test_data_depends_on_new_file
+        @adapter.with_tracking do
+          create_timed_data(@adapter, OLDDATA, NEWDATA)
+          sleep(1)
+
+          file NEWFILE do
+            create_file(NEWFILE)
+          end
+          Task[NEWFILE].invoke
+
+          @ran = false
+          data NEWDATA => NEWFILE do
+            @ran = true
+          end
+
+          Task[NEWDATA].invoke
+          assert @ran, "Should have run the data task with an updated file dependency."
+        end
+      end
+
+      def test_data_depends_on_new_file
+        @adapter.with_tracking do
+          file NEWFILE do
+            create_file(NEWFILE)
+          end
+          Task[NEWFILE].invoke
+
+          sleep(1)
+          create_timed_data(@adapter, OLDDATA, NEWDATA)
+
+          @ran = false
+          data @adapter[NEWDATA] => NEWFILE do
+            @ran = true
+          end
+
+          Task[@adapter[NEWDATA]].invoke
+          assert !@ran, "Should not have run the data task with an old file dependency."
+        end
+      end
+
+      def test_file_depends_on_new_data
+        @adapter.with_tracking do
+          create_file(NEWFILE)
+          sleep(1)
+
+          data @adapter[NEWDATA] do
+            create_timed_data(@adapter, OLDDATA, NEWDATA)
+          end
+          Task[@adapter[NEWDATA]].invoke
+
+          @ran = false
+          file NEWFILE => @adapter[NEWDATA] do
+            @ran = true
+          end
+
+          Task[@adapter[NEWFILE]].invoke
+          assert @ran, "Should have run the file task with an updated data dependency."
+        end
+      end
+
+      def test_file_depends_on_old_data
+        @adapter.with_tracking do
+          data @adapter[NEWDATA] do
+            create_timed_data(@adapter, OLDDATA, NEWDATA)
+          end
+          Task[@adapter[NEWDATA]].invoke
+
+          sleep(1)
+          create_file(NEWFILE)
+
+          @ran = false
+          file NEWFILE => @adapter[NEWDATA] do
+            @ran = true
+          end
+
+          Task[@adapter[NEWFILE]].invoke
+          assert !@ran, "Should not have run the file task with an old data dependency."
+        end
+      end
+
+      def load_phony
+        load File.join(@rake_lib, "rake/phony.rb")
+      end
+
+    end
+
+  end
+end