chrono_model 1.2.2 → 2.0.0

data/spec/chrono_model/time_machine/time_query_spec.rb

@@ -1,261 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe ChronoModel::TimeMachine::TimeQuery do
-  include ChronoTest::TimeMachine::Helpers
-
-  adapter.create_table 'events' do |t|
-    t.string :name
-    t.daterange :interval
-  end
-
-  class ::Event < ActiveRecord::Base
-    extend ChronoModel::TimeMachine::TimeQuery
-  end
-
-  # Main timeline quick test
-  #
-  it { expect(Foo.history.time_query(:after,  :now, inclusive: true ).count).to eq 3 }
-  it { expect(Foo.history.time_query(:after,  :now, inclusive: false).count).to eq 0 }
-  it { expect(Foo.history.time_query(:before, :now, inclusive: true ).count).to eq 5 }
-  it { expect(Foo.history.time_query(:before, :now, inclusive: false).count).to eq 2 }
-
-  it { expect(Foo.history.past.size).to eq 2 }
-
-  # Extended thorough test.
-  #
-  # Create a set of events and then run time queries on them.
-  #
-  think   = Event.create! name: 'think',   interval: (15.days.ago.to_date...13.days.ago.to_date)
-  plan    = Event.create! name: 'plan',    interval: (14.days.ago.to_date...12.days.ago.to_date)
-  collect = Event.create! name: 'collect', interval: (12.days.ago.to_date...10.days.ago.to_date)
-  start   = Event.create! name: 'start',   interval: (8.days.ago.to_date...7.days.ago.to_date)
-  build   = Event.create! name: 'build',   interval: (7.days.ago.to_date...Date.yesterday)
-  profit  = Event.create! name: 'profit',  interval: (Date.tomorrow...1.year.from_now.to_date)
-
-  describe :at do
-    describe 'with a single timestamp' do
-      subject { Event.time_query(:at, time.try(:to_date) || time, on: :interval).to_a }
-
-      context 'no records' do
-        let(:time) { 16.days.ago }
-        it { is_expected.to be_empty }
-      end
-
-      context 'single record' do
-        let(:time) { 15.days.ago }
-        it { is_expected.to eq [think] }
-      end
-
-      context 'multiple overlapping records' do
-        let(:time) { 14.days.ago }
-        it { is_expected.to match_array [think, plan] }
-      end
-
-      context 'on an edge of an open interval' do
-        let(:time) { 10.days.ago }
-        it { is_expected.to be_empty }
-      end
-
-      context 'in an hole' do
-        let(:time) { 9.days.ago }
-        it { is_expected.to be_empty }
-      end
-
-      context 'today' do
-        let(:time) { Date.today }
-        it { is_expected.to be_empty }
-      end
-
-      context 'server-side :today' do
-        let(:time) { :today }
-        it { is_expected.to be_empty }
-      end
-    end
-
-    describe 'with a range' do
-      subject { Event.time_query(:at, times.map!(&:to_date), on: :interval, type: :daterange).to_a }
-
-      context 'that is empty' do
-        let(:times) { [ 14.days.ago, 14.days.ago ] }
-        it { is_expected.to_not be_empty }
-      end
-
-      context 'overlapping no records' do
-        let(:times) { [ 20.days.ago, 16.days.ago ] }
-        it { is_expected.to be_empty }
-      end
-
-      context 'overlapping a single record' do
-        let(:times) { [ 16.days.ago, 14.days.ago ] }
-        it { is_expected.to eq [think] }
-      end
-
-      context 'overlapping more records' do
-        let(:times) { [ 16.days.ago, 11.days.ago ] }
-        it { is_expected.to match_array [think, plan, collect] }
-      end
-
-      context 'on the edge of an open interval and an hole' do
-        let(:times) { [ 10.days.ago, 9.days.ago ] }
-        it { is_expected.to be_empty }
-      end
-    end
-  end
-
-  describe :before do
-    let(:inclusive) { true }
-    subject { Event.time_query(:before, time.try(:to_date) || time, on: :interval, type: :daterange, inclusive: inclusive).to_a }
-
-    context '16 days ago' do
-      let(:time) { 16.days.ago }
-      it { is_expected.to be_empty }
-    end
-
-    context '14 days ago' do
-      let(:time) { 14.days.ago }
-      it { is_expected.to eq [think] }
-
-      context 'not inclusive' do
-        let(:inclusive) { false }
-        it { is_expected.to be_empty }
-      end
-    end
-
-    context '11 days ago' do
-      let(:time) { 11.days.ago }
-      it { is_expected.to match_array [think, plan, collect] }
-
-      context 'not inclusive' do
-        let(:inclusive) { false }
-        it { is_expected.to eq [think, plan] }
-      end
-    end
-
-    context '10 days ago' do
-      let(:time) { 10.days.ago }
-      it { is_expected.to match_array [think, plan, collect] }
-    end
-
-    context '8 days ago' do
-      let(:time) { 8.days.ago }
-      it { is_expected.to match_array [think, plan, collect] }
-    end
-
-    context 'today' do
-      let(:time) { Date.today }
-      it { is_expected.to match_array [think, plan, collect, start, build] }
-    end
-
-    context ':today' do
-      let(:time) { :today }
-      it { is_expected.to match_array [think, plan, collect, start, build] }
-    end
-  end
-
-  describe :after do
-    let(:inclusive) { true }
-    subject { Event.time_query(:after, time.try(:to_date) || time, on: :interval, type: :daterange, inclusive: inclusive).to_a }
-
-    context 'one month ago' do
-      let(:time) { 1.month.ago }
-      it { is_expected.to match_array [think, plan, collect, start, build, profit] }
-    end
-
-    context '10 days ago' do
-      let(:time) { 10.days.ago }
-      it { is_expected.to match_array [start, build, profit] }
-    end
-
-    context 'yesterday' do
-      let(:time) { Date.yesterday }
-      it { is_expected.to eq [profit] }
-    end
-
-    context 'today' do
-      let(:time) { Date.today }
-      it { is_expected.to eq [profit] }
-    end
-
-    context 'server-side :today' do
-      let(:time) { :today }
-      it { is_expected.to eq [profit] }
-    end
-
-    context 'tomorrow' do
-      let(:time) { Date.tomorrow }
-      it { is_expected.to eq [profit] }
-    end
-
-    context 'one month from now' do
-      let(:time) { 1.month.from_now }
-      it { is_expected.to eq [profit] }
-
-      context 'not inclusive' do
-        let(:inclusive) { false }
-        it { is_expected.to be_empty }
-      end
-    end
-
-    context 'far future' do
-      let(:time) { 1.year.from_now }
-      it { is_expected.to be_empty }
-    end
-  end
-
-  describe :not do
-    context 'with a single timestamp' do
-      subject { Event.time_query(:not, time.try(:to_date) || time, on: :interval, type: :daterange).to_a }
-
-      context '14 days ago' do
-        let(:time) { 14.days.ago }
-        it { is_expected.to match_array [collect, start, build, profit] }
-      end
-
-      context '9 days ago' do
-        let(:time) { 9.days.ago }
-        it { is_expected.to match_array [think, plan, collect, start, build, profit] }
-      end
-
-      context '8 days ago' do
-        let(:time) { 8.days.ago }
-        it { is_expected.to match_array [think, plan, collect, build, profit] }
-      end
-
-      context 'today' do
-        let(:time) { Date.today }
-        it { is_expected.to match_array [think, plan, collect, start, build, profit] }
-      end
-
-      context ':today' do
-        let(:time) { :today }
-        it { is_expected.to match_array [think, plan, collect, start, build, profit] }
-      end
-
-      context '1 month from now' do
-        let(:time) { 1.month.from_now }
-        it { is_expected.to match_array [think, plan, collect, start, build] }
-      end
-    end
-
-    context 'with a range' do
-      subject { Event.time_query(:not, time.map(&:to_date), on: :interval, type: :daterange).to_a }
-
-      context 'eliminating a single record' do
-        let(:time) { [1.month.ago, 14.days.ago] }
-        it { is_expected.to match_array [plan, collect, start, build, profit] }
-      end
-
-      context 'eliminating multiple records' do
-        let(:time) { [1.month.ago, Date.today] }
-        it { is_expected.to eq [profit] }
-      end
-
-      context 'from an edge' do
-        let(:time) { [14.days.ago, 10.days.ago] }
-        it { is_expected.to eq [start, build, profit] }
-      end
-    end
-  end
-
-end

data/spec/chrono_model/time_machine/timeline_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe ChronoModel::TimeMachine do
-  include ChronoTest::TimeMachine::Helpers
-
-  describe '#timeline' do
-    split = lambda {|ts| ts.map!{|t| [t.to_i, t.usec]} }
-
-    timestamps_from = lambda {|*records|
-      records.map(&:history).flatten!.inject([]) {|ret, rec|
-        ret.push [rec.valid_from.to_i, rec.valid_from.usec] if rec.try(:valid_from)
-        ret.push [rec.valid_to  .to_i, rec.valid_to  .usec] if rec.try(:valid_to)
-        ret
-      }.sort.uniq
-    }
-
-    describe 'on records having an :has_many relationship' do
-      describe 'by default returns timestamps of the record only' do
-        subject { split.call($t.foo.timeline) }
-
-        it { expect(subject.size).to eq $t.foo.ts.size }
-        it { is_expected.to eq timestamps_from.call($t.foo) }
-      end
-
-      describe 'when asked, returns timestamps including the related objects' do
-        subject { split.call($t.foo.timeline(with: :bars)) }
-
-        it { expect(subject.size).to eq($t.foo.ts.size + $t.bar.ts.size) }
-        it { is_expected.to eq(timestamps_from.call($t.foo, *$t.foo.bars)) }
-      end
-    end
-
-    describe 'on records using has_timeline :with' do
-      subject { split.call($t.bar.timeline) }
-
-      describe 'returns timestamps of the record and its associations' do
-
-        let!(:expected) do
-          creat = $t.bar.history.first.valid_from
-          c_sec, c_usec = creat.to_i, creat.usec
-
-          timestamps_from.call($t.foo, $t.bar).reject {|sec, usec|
-            sec < c_sec || ( sec == c_sec && usec < c_usec )
-          }
-        end
-
-        it { expect(subject.size).to eq expected.size }
-        it { is_expected.to eq expected }
-      end
-    end
-
-    describe 'on non-temporal records using has_timeline :with' do
-      subject { split.call($t.baz.timeline) }
-
-      describe 'returns timestamps of its temporal associations' do
-        it { expect(subject.size).to eq $t.bar.ts.size }
-        it { is_expected.to eq timestamps_from.call($t.bar) }
-      end
-    end
-  end
-
-end

data/spec/chrono_model/time_machine/timestamps_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe ChronoModel::TimeMachine do
-  include ChronoTest::TimeMachine::Helpers
-
-  history_methods = %w( valid_from valid_to recorded_at )
-  current_methods = %w( as_of_time )
-
-  context 'on history records' do
-    let(:record) { $t.foo.history.first }
-
-    (history_methods + current_methods).each do |attr|
-      describe ['#', attr].join do
-        subject { record.public_send(attr) }
-
-        it { is_expected.to be_present }
-        it { is_expected.to be_a(Time) }
-        it { is_expected.to be_utc }
-      end
-    end
-  end
-
-  context 'on current records' do
-    let(:record) { $t.foo }
-
-    history_methods.each do |attr|
-      describe ['#', attr].join do
-        subject { record.public_send(attr) }
-
-        it { expect { subject }.to raise_error(NoMethodError) }
-      end
-    end
-
-    current_methods.each do |attr|
-      describe ['#', attr].join do
-        subject { record.public_send(attr) }
-
-        it { is_expected.to be(nil) }
-      end
-    end
-  end
-end

data/spec/chrono_model/time_machine/transactions_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe ChronoModel::TimeMachine do
-  include ChronoTest::TimeMachine::Helpers
-
-  # Transactions
-  context 'multiple updates to an existing record' do
-    let!(:r1) do
-      Foo.create!(:name => 'xact test').tap do |record|
-        Foo.transaction do
-          record.update_attribute 'name', 'lost into oblivion'
-          record.update_attribute 'name', 'does work'
-        end
-      end
-    end
-
-    it "generate only a single history record" do
-      expect(r1.history.size).to eq(2)
-
-      expect(r1.history.first.name).to eq 'xact test'
-      expect(r1.history.last.name).to  eq 'does work'
-    end
-
-    after do
-      r1.destroy
-      r1.history.delete_all
-    end
-  end
-
-  context 'insertion and subsequent update' do
-    let!(:r2) do
-      Foo.transaction do
-        Foo.create!(:name => 'lost into oblivion').tap do |record|
-          record.update_attribute 'name', 'I am Bar'
-          record.update_attribute 'name', 'I am Foo'
-        end
-      end
-    end
-
-    it 'generates a single history record' do
-      expect(r2.history.size).to eq(1)
-      expect(r2.history.first.name).to eq 'I am Foo'
-    end
-
-    after do
-      r2.destroy
-      r2.history.delete_all
-    end
-  end
-
-  context 'insertion and subsequent deletion' do
-    let!(:r3) do
-      Foo.transaction do
-        Foo.create!(:name => 'it never happened').destroy
-      end
-    end
-
-    it 'does not generate any history' do
-      expect(Foo.history.where(:id => r3.id)).to be_empty
-    end
-
-    after do
-      r3.destroy
-      r3.history.delete_all
-    end
-  end
-
-end

data/spec/config.travis.yml

@@ -1,5 +0,0 @@
-hostname: localhost
-username: postgres
-password: ""
-database: chronomodel
-pool: 11

data/spec/config.yml.example

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

data/spec/spec_helper.rb

@@ -1,33 +0,0 @@
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-#
-require 'simplecov'
-SimpleCov.start
-
-require 'byebug'
-
-require 'chrono_model'
-
-require 'support/connection'
-require 'support/matchers/schema'
-require 'support/matchers/table'
-require 'support/matchers/column'
-require 'support/matchers/index'
-require 'support/matchers/function'
-require 'support/aruba'
-
-puts "Testing against Active Record #{ActiveRecord::VERSION::STRING} with Arel #{Arel::VERSION}"
-
-RSpec.configure do |config|
-  config.include(ChronoTest::Matchers::Schema)
-  config.include(ChronoTest::Matchers::Table)
-  config.include(ChronoTest::Matchers::Column)
-  config.include(ChronoTest::Matchers::Index)
-  config.include(ChronoTest::Aruba, type: :aruba)
-
-  ChronoTest.recreate_database!
-
-  config.before(:example, type: :aruba) do
-    copy_dummy_app_into_aruba_working_directory
-    recreate_railsapp_database
-  end
-end

data/spec/support/adapter/helpers.rb

@@ -1,53 +0,0 @@
-module ChronoTest::Adapter
-
-  module Helpers
-    def self.included(base)
-      base.extend DSL
-
-      base.instance_eval do
-        delegate :adapter, :to => ChronoTest
-        delegate :columns, :table, :pk_type, :to => DSL
-      end
-    end
-
-    module DSL
-      def with_temporal_table(&block)
-        context ':temporal => true' do
-          before(:all) { adapter.create_table(table, :temporal => true, &DSL.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, &DSL.columns) }
-          after(:all)  { adapter.drop_table table }
-
-          instance_eval(&block)
-        end
-      end
-
-      def self.table(table = nil)
-        @table = table if table
-        @table
-      end
-
-      def self.columns(&block)
-        @columns = block.call if block
-        @columns
-      end
-
-      def self.pk_type
-        @pk_type ||= if ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR >= 1
-          'bigint'
-        else
-          'integer'
-        end
-      end
-      delegate :columns, :table, :pk_type, :to => self
-    end
-  end
-
-end

data/spec/support/adapter/structure.rb

@@ -1,44 +0,0 @@
-require 'support/adapter/helpers'
-
-# This module contains the definition of a test structure that is used by the
-# adapter methods tests, that look up in the database directly whether the
-# expected objects have been created.
-#
-# The structure defintiion below serves as a blueprint of what it can be
-# defined, ans as a reference of what it is expected to have been created by
-# the +ChronoModel::Adapter+ methods.
-#
-module ChronoTest::Adapter
-
-  module Structure
-    extend ActiveSupport::Concern
-
-    included do
-      table 'test_table'
-      subject { table }
-
-      columns do
-        native = [
-          ['test', 'character varying'],
-          ['foo',  'integer'],
-          ['bar',  'double precision'],
-          ['baz',  'text']
-        ]
-
-        def native.to_proc
-          proc {|t|
-            t.string  :test, null: false, default: 'default-value'
-            t.integer :foo
-            t.float   :bar
-            t.text    :baz
-            t.integer :ary, array: true, null: false, default: []
-            t.boolean :bool, null: false, default: false
-          }
-        end
-
-        native
-      end
-    end
-  end
-
-end

data/spec/support/aruba.rb

@@ -1,44 +0,0 @@
-require 'aruba/rspec'
-require 'arel'
-
-module ChronoTest
-
-  module Aruba
-    def aruba_working_directory
-      File.expand_path("../../#{::Aruba.config.working_directory}", __dir__)
-    end
-
-    def dummy_app_directory
-      File.expand_path("../../tmp/railsapp/", __dir__)
-    end
-
-    def copy_dummy_app_into_aruba_working_directory
-      unless File.file?(Pathname.new(dummy_app_directory).join('Rakefile'))
-        raise %q(
-          The dummy application does not exist
-          Run `bundle exec rake testapp:create`
-        )
-      end
-      FileUtils.rm_rf(Dir.glob("#{aruba_working_directory}/*"))
-      FileUtils.cp_r(Dir.glob("#{dummy_app_directory}/*"), aruba_working_directory)
-    end
-
-    def recreate_railsapp_database
-      connection = AR.connection # we're still the 'chronomodel' user
-      database = 'chronomodel_railsapp'
-      connection.drop_database   database
-      connection.create_database database
-    end
-
-    def file_mangle!(file, &block)
-      # Read
-      file_contents = read(file).join("\n")
-
-      # Mangle
-      file_contents = block.call(file_contents)
-
-      # Write
-      write_file file, file_contents
-    end
-  end
-end

data/spec/support/connection.rb

@@ -1,70 +0,0 @@
-require 'pathname'
-require 'active_record'
-
-module ChronoTest
-  extend self
-
-  AR = ActiveRecord::Base
-  log = ENV['VERBOSE'].present? ? $stderr : 'spec/debug.log'.tap{|f| File.open(f, "ab") { |ft| ft.truncate(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
-  alias :adapter :connection
-
-  def recreate_database!
-    database = config.fetch(:database)
-    connect! config.merge(:database => :postgres)
-
-    connection.drop_database   database
-    connection.create_database database
-    connect! config
-
-    connection.execute 'CREATE EXTENSION btree_gist'
-    logger.info "Connected to #{config}"
-  end
-
-  def config
-    @config ||= YAML.load(config_file.read).tap do |conf|
-      conf.symbolize_keys!
-      conf.update(:adapter => 'chronomodel')
-
-      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