chrono_model 0.3.0

data/spec/config.yml.example

@@ -0,0 +1,7 @@
+# CREATE ROLE chronomodel LOGIN ENCRYPTED PASSWORD 'chronomodel' CREATEDB;
+#
+hostname: localhost
+username: chronomodel
+password: chronomodel
+database: chronomodel
+#

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+#
+require 'chrono_model'
+
+require 'support/connection'
+require 'support/matchers/schema'
+require 'support/matchers/table'
+require 'support/matchers/column'
+require 'support/matchers/index'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  config.include(ChronoTest::Matchers::Schema)
+  config.include(ChronoTest::Matchers::Table)
+  config.include(ChronoTest::Matchers::Column)
+  config.include(ChronoTest::Matchers::Index)
+
+  config.before :suite do
+    ChronoTest.recreate_database!
+  end
+end

data/spec/support/connection.rb

@@ -0,0 +1,74 @@
+require 'pathname'
+require 'active_record'
+require 'active_support/core_ext/logger'
+
+module ChronoTest
+  extend self
+
+  AR = ActiveRecord::Base
+  log = ENV['VERBOSE'].present? ? $stderr : 'spec/debug.log'.tap{|f| File.truncate(f, 0)}
+  AR.logger = ::Logger.new(log).tap do |l|
+    l.level = 0
+  end
+
+  def connect!(spec = self.config)
+    unless ENV['VERBOSE'].present?
+      spec = spec.merge(:min_messages => 'WARNING')
+    end
+    AR.establish_connection spec
+  end
+
+  def logger
+    AR.logger
+  end
+
+  def connection
+    AR.connection
+  end
+
+  def recreate_database!
+    database = config.fetch(:database)
+    connect! config.merge(:database => 'postgres')
+
+    unless AR.supports_chrono?
+      raise 'Your postgresql version is not supported. >= 9.0 is required.'
+    end
+
+    connection.drop_database   database
+    connection.create_database database
+
+  ensure
+    connect!
+    logger.info "Connected to #{config}"
+  end
+
+  def config
+    @config ||= YAML.load(config_file.read).tap do |conf|
+      conf.symbolize_keys!
+      conf.update(:adapter => 'postgresql')
+
+      def conf.to_s
+        'pgsql://%s:%s@%s/%s' % [
+          self[:username], self[:password], self[:hostname], self[:database]
+        ]
+      end
+    end
+
+  rescue Errno::ENOENT
+    $stderr.puts <<EOM
+
+Please define your AR database configuration
+in spec/config.yml or reference your own configuration
+file using the TEST_CONFIG environment variable
+EOM
+
+    abort
+  end
+
+  def config_file
+    Pathname(ENV['TEST_CONFIG'] ||
+      File.join(File.dirname(__FILE__), '..', 'config.yml')
+    )
+  end
+
+end

data/spec/support/helpers.rb

@@ -0,0 +1,123 @@
+module ChronoTest::Helpers
+
+  module Adapter
+    def self.included(base)
+      base.let!(:adapter) { ChronoTest.connection }
+      base.extend DSL
+    end
+
+    def columns
+      DSL.columns
+    end
+
+    module DSL
+      def with_temporal_table(&block)
+        context ':temporal => true' do
+          before(:all) { adapter.create_table(table, :temporal => true, &columns) }
+          after(:all)  { adapter.drop_table table }
+
+          instance_eval(&block)
+        end
+      end
+
+      def with_plain_table(&block)
+        context ':temporal => false' do
+          before(:all) { adapter.create_table(table, :temporal => false, &columns) }
+          after(:all)  { adapter.drop_table table }
+
+          instance_eval(&block)
+        end
+      end
+
+      def columns(&block)
+        DSL.columns = block.call
+      end
+
+      class << self
+        attr_accessor :columns
+      end
+    end
+  end
+
+  module TimeMachine
+    def self.included(base)
+      base.let!(:adapter) { ChronoTest.connection }
+      base.extend(DSL)
+    end
+
+    module DSL
+      def setup_schema!
+        # Set up database structure
+        #
+        before(:all) do
+          adapter.create_table 'foos', :temporal => true do |t|
+            t.string     :name
+            t.integer    :fooity
+          end
+
+          adapter.create_table 'bars', :temporal => true do |t|
+            t.string     :name
+            t.references :foo
+          end
+
+          adapter.create_table 'bazs' do |t|
+            t.string     :name
+            t.references :bar
+          end
+        end
+
+        after(:all) do
+          adapter.drop_table 'foos'
+          adapter.drop_table 'bars'
+          adapter.drop_table 'bazs'
+        end
+      end
+
+      Models = lambda {
+        class ::Foo < ActiveRecord::Base
+          include ChronoModel::TimeMachine
+
+          has_many :bars
+        end
+
+        class ::Bar < ActiveRecord::Base
+          include ChronoModel::TimeMachine
+
+          belongs_to :foo
+          has_one :baz
+        end
+
+        class ::Baz < ActiveRecord::Base
+          belongs_to :baz
+        end
+      }
+
+      def define_models!
+        before(:all) { Models.call }
+      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 = adapter.select_value('select now()::timestamp')
+        obj.ts.push(Time.parse(now))
+      end
+    end
+  end
+
+end

data/spec/support/matchers/base.rb

@@ -0,0 +1,59 @@
+require 'ostruct'
+
+module ChronoTest::Matchers
+  class Base
+    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
+      FooColumn = OpenStruct.new(:name => '')
+
+      def exec_query(sql, binds, name)
+        binds.map! do |col, val|
+          val ? [col, val] : [FooColumn, col]
+        end
+        connection.exec_query(sql, name, binds)
+      end
+  end
+
+end

data/spec/support/matchers/column.rb

@@ -0,0 +1,83 @@
+module ChronoTest::Matchers
+
+  module Column
+    class HaveColumns < ChronoTest::Matchers::Base
+      def initialize(columns, schema = 'public')
+        @columns = columns
+        @schema  = schema
+      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_for_should
+        "expected #{@schema}.#{table} to have ".tap do |message|
+          message << @matches.map do |(name, type), match|
+            "a #{name}(#{type}) column" unless match
+          end.compact.to_sentence
+        end
+      end
+
+      protected
+        def has_column?(name, type)
+          table = "#{@schema}.#{self.table}"
+
+          select_rows(<<-SQL, [table, name], 'Check column').first == [name, type]
+            SELECT attname, FORMAT_TYPE(atttypid, atttypmod)
+              FROM pg_attribute
+             WHERE attrelid = $1::regclass::oid
+               AND attname = $2
+          SQL
+        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([
+          ['valid_from',  'timestamp without time zone'],
+          ['valid_to',    'timestamp without time zone'],
+          ['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/index.rb

@@ -0,0 +1,61 @@
+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 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 = $1
+             AND i.relname = $2
+             AND i.relnamespace = (
+              SELECT oid FROM pg_namespace WHERE nspname = $3
+            )
+           ORDER BY a.attname
+        SQL
+      end
+
+      def failure_message_for_should
+        "expected #{schema}.#{table} to 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

@@ -0,0 +1,31 @@
+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 failure_message_for_should
+        "expected to be in schema #@expected, but was in #@current"
+      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