chrono_model 1.2.2 → 2.0.0

data/spec/support/matchers/base.rb

@@ -1,56 +0,0 @@
-module ChronoTest::Matchers
-  class Base
-    include ActiveRecord::Sanitization::ClassMethods
-
-    attr_reader :table
-
-    def matches?(table)
-      table = table.table_name if table.respond_to?(:table_name)
-      @table = table
-    end
-    private :matches? # This is an abstract class
-
-    def failure_message_for_should_not
-      failure_message_for_should.gsub(/to /, 'to not ')
-    end
-
-    protected
-
-      def connection
-        ChronoTest.connection
-      end
-
-      def temporal_schema
-        ChronoModel::Adapter::TEMPORAL_SCHEMA
-      end
-
-      def history_schema
-        ChronoModel::Adapter::HISTORY_SCHEMA
-      end
-
-      def public_schema
-        'public'
-      end
-
-      def select_value(sql, binds, name = nil)
-        result = exec_query(sql, binds, name || 'select_value')
-        result.rows.first.try(:[], 0)
-      end
-
-      def select_values(sql, binds, name = nil)
-        result = exec_query(sql, binds, name || 'select_values')
-        result.rows.map(&:first)
-      end
-
-      def select_rows(sql, binds, name = nil)
-        exec_query(sql, binds, name || 'select_rows').rows
-      end
-
-    private
-      def exec_query(sql, binds, name)
-        sql = sanitize_sql_array([ sql, *Array.wrap(binds) ])
-        connection.exec_query(sql, name)
-      end
-  end
-
-end

data/spec/support/matchers/column.rb

@@ -1,99 +0,0 @@
-module ChronoTest::Matchers
-
-  module Column
-    class HaveColumns < ChronoTest::Matchers::Base
-      def initialize(columns, schema = 'public')
-        @columns = columns
-        @schema  = schema
-      end
-
-      def description
-        'have columns'
-      end
-
-      def matches?(table)
-        super(table)
-
-        @matches = @columns.inject({}) do |h, (name, type)|
-          h.update([name, type] => has_column?(name, type))
-        end
-
-        @matches.values.all?
-      end
-
-      def failure_message
-        message_matches("expected #{@schema}.#{table} to have")
-      end
-
-      def failure_message_when_negated
-        message_matches("expected #{@schema}.#{table} to not have")
-      end
-
-      protected
-        def has_column?(name, type)
-          column_type(name) == [name, type]
-        end
-
-        def column_type(name)
-          table = "#{@schema}.#{self.table}"
-
-          select_rows(<<-SQL, [table, name], 'Check column').first
-            SELECT attname, FORMAT_TYPE(atttypid, atttypmod)
-              FROM pg_attribute
-             WHERE attrelid = ?::regclass::oid
-               AND attname = ?
-          SQL
-        end
-
-      private
-        def message_matches(message)
-          (message << ' ').tap do |message|
-            message << @matches.map do |(name, type), match|
-              "a #{name}(#{type}) column" unless match
-            end.compact.to_sentence
-          end
-        end
-    end
-
-    def have_columns(*args)
-      HaveColumns.new(*args)
-    end
-
-
-    class HaveTemporalColumns < HaveColumns
-      def initialize(columns)
-        super(columns, temporal_schema)
-      end
-    end
-
-    def have_temporal_columns(*args)
-      HaveTemporalColumns.new(*args)
-    end
-
-
-    class HaveHistoryColumns < HaveColumns
-      def initialize(columns)
-        super(columns, history_schema)
-      end
-    end
-
-    def have_history_columns(*args)
-      HaveHistoryColumns.new(*args)
-    end
-
-
-    class HaveHistoryExtraColumns < HaveColumns
-      def initialize
-        super([
-          ['validity',    'tsrange'],
-          ['recorded_at', 'timestamp without time zone'],
-          ['hid',         'integer']
-        ], history_schema)
-      end
-    end
-
-    def have_history_extra_columns
-      HaveHistoryExtraColumns.new
-    end
-  end
-end

data/spec/support/matchers/function.rb

@@ -1,79 +0,0 @@
-module ChronoTest::Matchers
-
-  module Column
-    class HaveFunctions < ChronoTest::Matchers::Base
-      def initialize(functions, schema = 'public')
-        @functions = functions
-        @schema    = schema
-      end
-
-      def description
-        'have functions'
-      end
-
-      def matches?(table)
-        super(table)
-
-        @matches = @functions.inject({}) do |h, name|
-          h.update(name => has_function?(name))
-        end
-
-        @matches.values.all?
-      end
-
-      def failure_message
-        message_matches("expected #{@schema}.#{table} to have")
-      end
-
-      def failure_message_when_negated
-        message_matches("expected #{@schema}.#{table} to not have")
-      end
-
-      protected
-        def has_function?(name)
-          select_value(<<-SQL, [name], 'Check function') == true
-            SELECT EXISTS(
-              SELECT 1
-              FROM pg_catalog.pg_proc p, pg_catalog.pg_namespace n
-              WHERE p.pronamespace = n.oid
-                AND n.nspname = 'public'
-                AND p.proname = ?
-            )
-          SQL
-        end
-
-      private
-        def message_matches(message)
-          (message << ' ').tap do |message|
-            message << @matches.map do |name, match|
-              "a #{name} function"
-            end.compact.to_sentence
-          end
-        end
-    end
-
-    def have_functions(*args)
-      HaveFunctions.new(*args)
-    end
-
-    class HaveHistoryFunctions < HaveFunctions
-      def initialize
-        @function_templates = [
-          'chronomodel_%s_insert',
-          'chronomodel_%s_update',
-          'chronomodel_%s_delete',
-        ]
-      end
-
-      def matches?(table)
-        @functions = @function_templates.map {|t| t % [table] }
-
-        super(table)
-      end
-    end
-
-    def have_history_functions
-      HaveHistoryFunctions.new
-    end
-  end
-end

data/spec/support/matchers/index.rb

@@ -1,69 +0,0 @@
-module ChronoTest::Matchers
-
-  module Index
-    class HaveIndex < ChronoTest::Matchers::Base
-      attr_reader :name, :columns, :schema
-
-      def initialize(name, columns, schema = 'public')
-        @name    = name
-        @columns = columns.sort
-        @schema  = schema
-      end
-
-      def description
-        'have index'
-      end
-
-      def matches?(table)
-        super(table)
-
-        select_values(<<-SQL, [ table, name, schema ], 'Check index') == columns
-          SELECT a.attname
-            FROM pg_class t
-            JOIN pg_index d ON t.oid = d.indrelid
-            JOIN pg_class i ON i.oid = d.indexrelid
-            JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(d.indkey)
-           WHERE i.relkind = 'i'
-             AND t.relname = ?
-             AND i.relname = ?
-             AND i.relnamespace = (
-              SELECT oid FROM pg_namespace WHERE nspname = ?
-            )
-           ORDER BY a.attname
-        SQL
-      end
-
-      def failure_message
-        "expected #{schema}.#{table} to have a #{name} index on #{columns}"
-      end
-
-      def failure_message_when_negated
-        "expected #{schema}.#{table} to not have a #{name} index on #{columns}"
-      end
-    end
-
-    def have_index(*args)
-      HaveIndex.new(*args)
-    end
-
-    class HaveTemporalIndex < HaveIndex
-      def initialize(name, columns)
-        super(name, columns, temporal_schema)
-      end
-    end
-
-    def have_temporal_index(*args)
-      HaveTemporalIndex.new(*args)
-    end
-
-    class HaveHistoryIndex < HaveIndex
-      def initialize(name, columns)
-        super(name, columns, history_schema)
-      end
-    end
-
-    def have_history_index(*args)
-      HaveHistoryIndex.new(*args)
-    end
-  end
-end

data/spec/support/matchers/schema.rb

@@ -1,39 +0,0 @@
-require 'support/matchers/base'
-
-module ChronoTest::Matchers
-
-  module Schema
-    class BeInSchema < ChronoTest::Matchers::Base
-
-      def initialize(expected)
-        @expected = expected
-        @expected = '"$user", public' if @expected == :default
-      end
-
-      def description
-        'be in schema'
-      end
-
-      def failure_message
-        "expected to be in schema #@expected, but was in #@current"
-      end
-
-      def failure_message_when_negated
-        "expected to be in schema #@current, but was in #@expected"
-      end
-
-      def matches?(*)
-        @current = select_value(<<-SQL, [], 'Current schema')
-          SHOW search_path
-        SQL
-
-        @current == @expected
-      end
-    end
-
-    def be_in_schema(schema)
-      BeInSchema.new(schema)
-    end
-  end
-
-end

data/spec/support/matchers/table.rb

@@ -1,275 +0,0 @@
-require 'support/matchers/base'
-
-module ChronoTest::Matchers
-
-  module Table
-    class Base < ChronoTest::Matchers::Base
-
-      protected
-        # Database statements
-        #
-        def relation_exists?(options)
-          schema = options[:in]
-          kind   = options[:kind] == :view ? 'v' : 'r'
-
-          select_value(<<-SQL, [ table, schema ], 'Check table exists') == true
-            SELECT EXISTS (
-              SELECT 1
-                FROM pg_class c
-                LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-               WHERE c.relkind = '#{kind}'
-                 AND c.relname = ?
-                 AND n.nspname = ?
-            )
-          SQL
-        end
-    end
-
-    # ##################################################################
-    # Checks that a table exists in the Public schema
-    #
-    class HavePublicBacking < Base
-      def matches?(table)
-        super(table)
-
-        relation_exists? :in => public_schema
-      end
-
-      def description
-        'be in the public schema'
-      end
-
-      def failure_message
-        "expected #{table} to exist in the #{public_schema} schema"
-      end
-
-      def failure_message_when_negated
-        "expected #{table} to not exist in the #{public_schema} schema"
-      end
-    end
-
-    def have_public_backing
-      HavePublicBacking.new
-    end
-
-
-    # ##################################################################
-    # Checks that a table exists in the Temporal schema
-    #
-    class HaveTemporalBacking < Base
-      def matches?(table)
-        super(table)
-
-        relation_exists? :in => temporal_schema
-      end
-
-      def description
-        'be in the temporal schema'
-      end
-
-      def failure_message
-        "expected #{table} to exist in the #{temporal_schema} schema"
-      end
-
-      def failure_message_when_negated
-        "expected #{table} to not exist in the #{temporal_schema} schema"
-      end
-    end
-
-    def have_temporal_backing
-      HaveTemporalBacking.new
-    end
-
-
-    # ##################################################################
-    # Checks that a table exists in the History schema and inherits from
-    # the one in the Temporal schema
-    #
-    class HaveHistoryBacking < Base
-      def matches?(table)
-        super(table)
-
-        table_exists?           &&
-        inherits_from_temporal? &&
-        has_consistency_constraint? &&
-        has_history_indexes?
-      end
-
-      def description
-        'be in history schema'
-      end
-
-      def failure_message
-        "expected #{table} ".tap do |message|
-          message << [
-            ("to exist in the #{history_schema} schema"    unless @existance),
-            ("to inherit from #{temporal_schema}.#{table}" unless @inheritance),
-            ("to have a timeline consistency constraint"   unless @constraint),
-            ("to have history indexes"                     unless @indexes)
-          ].compact.to_sentence
-        end
-      end
-
-      def failure_message_when_negated
-        "expected #{table} ".tap do |message|
-          message << [
-            ("to not exist in the #{history_schema} schema"    if @existance),
-            ("to not inherit from #{temporal_schema}.#{table}" if @inheritance),
-            ("to not have a timeline consistency constraint"   if @constraint),
-            ("to not have history indexes"                     if @indexes)
-          ].compact.to_sentence
-        end
-      end
-
-      private
-        def table_exists?
-          @existance = relation_exists? :in => history_schema
-        end
-
-        def inherits_from_temporal?
-          binds = ["#{history_schema}.#{table}", "#{temporal_schema}.#{table}"]
-
-          @inheritance = select_value(<<-SQL, binds, 'Check inheritance') == true
-            SELECT EXISTS (
-              SELECT 1 FROM pg_catalog.pg_inherits
-               WHERE inhrelid  = ?::regclass::oid
-                 AND inhparent = ?::regclass::oid
-            )
-          SQL
-        end
-
-        def has_history_indexes?
-          binds = [ history_schema, table ]
-
-          indexes = select_values(<<-SQL, binds, 'Check history indexes')
-            SELECT indexdef FROM pg_indexes
-             WHERE schemaname = ?
-               AND tablename  = ?
-          SQL
-
-          fqtn = [history_schema, table].join('.')
-
-          expected = [
-            "CREATE INDEX index_#{table}_temporal_on_lower_validity ON #{fqtn} USING btree (lower(validity))",
-            "CREATE INDEX index_#{table}_temporal_on_upper_validity ON #{fqtn} USING btree (upper(validity))",
-            "CREATE INDEX index_#{table}_temporal_on_validity ON #{fqtn} USING gist (validity)",
-
-            "CREATE INDEX #{table}_inherit_pkey ON #{fqtn} USING btree (id)",
-            "CREATE INDEX #{table}_instance_history ON #{fqtn} USING btree (id, recorded_at)",
-            "CREATE UNIQUE INDEX #{table}_pkey ON #{fqtn} USING btree (hid)",
-            "CREATE INDEX #{table}_recorded_at ON #{fqtn} USING btree (recorded_at)",
-            "CREATE INDEX #{table}_timeline_consistency ON #{fqtn} USING gist (id, validity)"
-          ]
-
-          @indexes = (expected - indexes).empty?
-        end
-
-        def has_consistency_constraint?
-          binds = {
-            conname:      connection.timeline_consistency_constraint_name(table),
-            connamespace: history_schema,
-            conrelid:     [history_schema, table].join('.'),
-            attname:      connection.primary_key(table)
-          }
-
-          @constraint = select_value(<<-SQL, binds, 'Check Consistency Constraint') == true
-            SELECT EXISTS (
-              SELECT 1 FROM pg_catalog.pg_constraint
-              WHERE conname = :conname
-                AND contype = 'x'
-                AND conrelid = :conrelid::regclass
-                AND connamespace = (
-                  SELECT oid FROM pg_catalog.pg_namespace WHERE nspname = :connamespace
-                )
-                AND conkey = (
-                  SELECT array_agg(attnum) FROM pg_catalog.pg_attribute
-                  WHERE attname IN (:attname, 'validity')
-                    AND attrelid = :conrelid::regclass
-                )
-            )
-          SQL
-        end
-    end
-
-    def have_history_backing
-      HaveHistoryBacking.new
-    end
-
-
-    # ##################################################################
-    # Checks that a table exists in the Public schema, is an updatable
-    # view and has an INSERT, UPDATE and DELETE triggers.
-    #
-    class HavePublicInterface < Base
-      def matches?(table)
-        super(table)
-
-        view_exists? && [ is_updatable?, has_triggers? ].all?
-      end
-
-      def description
-        'be an updatable view'
-      end
-
-      def failure_message
-        "expected #{table} ".tap do |message|
-          message << [
-            ("to exist in the #{public_schema} schema" unless @existance     ),
-            ('to be an updatable view'                 unless @updatable     ),
-            ('to have an INSERT trigger'               unless @insert_trigger),
-            ('to have an UPDATE trigger'               unless @update_trigger),
-            ('to have a DELETE trigger'                unless @delete_trigger)
-          ].compact.to_sentence
-        end
-      end
-
-      def failure_message_when_negated
-        "expected #{table} ".tap do |message|
-          message << [
-            ("to not exist in the #{public_schema} schema" if @existance     ),
-            ('to not be an updatable view'                 if @updatable     ),
-            ('to not have an INSERT trigger'               if @insert_trigger),
-            ('to not have an UPDATE trigger'               if @update_trigger),
-            ('to not have a DELETE trigger'                if @delete_trigger)
-          ].compact.to_sentence
-        end
-      end
-
-      private
-        def view_exists?
-          @existance = relation_exists? :in => public_schema, :kind => :view
-        end
-
-        def is_updatable?
-          binds = [ public_schema, table ]
-
-          @updatable = select_value(<<-SQL, binds, 'Check updatable') == 'YES'
-            SELECT is_updatable FROM information_schema.views
-             WHERE table_schema = ? AND table_name = ?
-          SQL
-        end
-
-        def has_triggers?
-          triggers = select_values(<<-SQL, [ public_schema, table ], 'Check triggers')
-            SELECT t.tgname
-              FROM pg_catalog.pg_trigger t, pg_catalog.pg_class c, pg_catalog.pg_namespace n
-             WHERE t.tgrelid = c.relfilenode
-               AND n.oid = c.relnamespace
-               AND n.nspname = ?
-               AND c.relname = ?;
-          SQL
-
-          @insert_trigger = triggers.include? 'chronomodel_insert'
-          @update_trigger = triggers.include? 'chronomodel_update'
-          @delete_trigger = triggers.include? 'chronomodel_delete'
-
-          @insert_trigger && @update_trigger && @delete_trigger
-        end
-    end
-
-    def have_public_interface
-      HavePublicInterface.new
-    end
-  end
-
-end

data/spec/support/time_machine/helpers.rb

@@ -1,47 +0,0 @@
-module ChronoTest::TimeMachine
-
-  # This module contains helpers used throughout the
-  # +ChronoModel::TimeMachine+ specs.
-  #
-  module Helpers
-    def self.included(base)
-      base.extend(self)
-    end
-
-    def adapter
-      ChronoTest.connection
-    end
-
-    def with_revert
-      adapter.transaction do
-        adapter.create_savepoint 'revert'
-
-        yield
-
-        adapter.exec_rollback_to_savepoint 'revert'
-      end
-    end
-
-    # If a context object is given, evaluates the given
-    # block in its instance context, then defines a `ts`
-    # on it, backed by an Array, and adds the current
-    # database timestamp to it.
-    #
-    # If a context object is not given, the block is
-    # evaluated in the current context and the above
-    # mangling is done on the blocks' return value.
-    #
-    def ts_eval(ctx = nil, &block)
-      ret = (ctx || self).instance_eval(&block)
-      (ctx || ret).tap do |obj|
-        obj.singleton_class.instance_eval do
-          define_method(:ts) { @_ts ||= [] }
-        end unless obj.methods.include?(:ts)
-
-        now = ChronoTest.connection.select_value('select now()::timestamp') + 'Z'
-        obj.ts.push(Time.parse(now))
-      end
-    end
-  end
-
-end