ballot 1.0

data/test/sequel/rails_generator_test.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'minitest_config'
+
+describe 'RailsGenerator' do
+  describe 'for Sequel' do
+    let(:orm_name) { 'sequel' }
+    let(:orm_version) { Sequel::VERSION }
+    let(:rails_version) { ActiveRecord::VERSION::STRING }
+
+    test_ballot_install(
+      generate: %r{create\s+db/migrate/\d+_install_ballot_vote_migration},
+      contents: /Sequel.migration.*create_table :ballot_votes do/m
+    )
+
+    test_ballot_summary_votable(
+      generate: %r{create\s+db/migrate/\d+_ballot_cache_for_votable},
+      contents: %r{
+        Sequel.migration.*
+        alter_table\s+:'votables'.*
+        add_column\s+:cached_ballot_summary,
+      }mx
+    )
+  end
+end

data/test/sequel/votable_voter_test.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'minitest_config'
+
+describe SequelVotableVoter do
+  describe_ballot_voter do
+    let(:voter) { SequelVotableVoter.create(name: 'I can vote!') }
+    let(:voter2) { SequelVotableVoter.create(name: 'I, too, can vote!') }
+    let(:votable) { voter2 }
+    let(:votable2) { voter }
+  end
+
+  describe_ballot_votable do
+    let(:voter) { SequelVotableVoter.create(name: 'I can vote!') }
+    let(:voter2) { SequelVotableVoter.create(name: 'I, too, can vote!') }
+    let(:votable) { voter2 }
+    let(:votable2) { voter }
+  end
+end

data/test/sequel/vote_test.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'minitest_config'
+
+describe Ballot::Sequel::Vote do
+  before do
+    voter.cast_up_ballot_for votable
+    voter.cast_up_ballot_for votable2
+    voter.cast_up_ballot_for votable_cache
+    voter2.cast_down_ballot_for votable
+    voter2.cast_down_ballot_for votable2
+    voter2.cast_down_ballot_for votable_cache
+    expected_votes # Force the query now
+  end
+
+  let(:expected_votes) {
+    [
+      Ballot::Sequel::Vote[1],
+      Ballot::Sequel::Vote[2],
+      Ballot::Sequel::Vote[3],
+      Ballot::Sequel::Vote[4],
+      Ballot::Sequel::Vote[5],
+      Ballot::Sequel::Vote[6]
+    ]
+  }
+
+  describe 'dataset_module' do
+    it 'provides an up subset' do
+      assert_equal 3, Ballot::Sequel::Vote.dataset.up.count
+      assert_equal 3, Ballot::Sequel::Vote.up.count
+    end
+
+    it 'provides a down subset' do
+      assert_equal 3, Ballot::Sequel::Vote.dataset.down.count
+      assert_equal 3, Ballot::Sequel::Vote.down.count
+    end
+
+    it 'provides a for_type filter' do
+      assert_empty Ballot::Sequel::Vote.dataset.for_type('SequelNotVotable')
+      assert_empty Ballot::Sequel::Vote.for_type(SequelNotVotable)
+      refute_empty Ballot::Sequel::Vote.dataset.for_type('SequelVotable')
+      refute_empty Ballot::Sequel::Vote.for_type(SequelVotable)
+    end
+
+    it 'provides a by_type filter' do
+      assert_empty Ballot::Sequel::Vote.dataset.by_type('SequelNotVoter')
+      assert_empty Ballot::Sequel::Vote.by_type(SequelNotVoter)
+      refute_empty Ballot::Sequel::Vote.dataset.by_type('SequelVoter')
+      refute_empty Ballot::Sequel::Vote.by_type(SequelVoter)
+    end
+  end
+
+  describe 'votable association' do
+    it 'defines #votable= correctly' do
+      v = Ballot::Sequel::Vote.new
+      v.votable = votable
+      assert_equal votable.id, v.votable_id
+      assert_equal Ballot::Sequel.type_name(votable), v.votable_type
+    end
+
+    it 'defines votable_dataset correctly' do
+      assert_equal votable, voter.ballots_by.first.votable
+    end
+
+    it 'defines eager loading correctly' do
+      sqls = capture_sql {
+        actual = Ballot::Sequel::Vote.eager(:votable).all
+        assert_equal expected_votes, actual
+        assert_equal [ votable, votable2, votable_cache ], actual.shift(3).map(&:votable)
+        assert_equal [ votable, votable2, votable_cache ], actual.shift(3).map(&:votable)
+      }
+
+      assert_match(/SELECT \* FROM `ballot_votes`/, sqls.shift)
+      assert_match(/SELECT \* FROM `votables` WHERE \(`id` IN \(1, 2\)\)/, sqls.shift)
+      assert_match(/SELECT \* FROM `votable_caches` WHERE \(`id` IN \(1\)\)/, sqls.shift)
+      assert_empty sqls
+    end
+  end
+
+  describe 'voter association' do
+    it 'defines #voter= correctly' do
+      v = Ballot::Sequel::Vote.new
+      v.voter = voter
+      assert_equal voter.id, v.voter_id
+      assert_equal Ballot::Sequel.type_name(voter), v.voter_type
+    end
+
+    it 'defines voter_dataset correctly' do
+      assert_equal voter, votable.ballots_for_dataset.first.voter
+    end
+
+    it 'defines eager loading correctly' do
+      sqls = capture_sql {
+        actual = Ballot::Sequel::Vote.eager(:voter).all
+        assert_equal expected_votes, actual
+        assert_equal [ voter ] * 3, actual.shift(3).map(&:voter)
+        assert_equal [ voter2 ] * 3, actual.shift(3).map(&:voter)
+      }
+
+      assert_match(/SELECT \* FROM `ballot_votes`/, sqls.shift)
+      assert_match(/SELECT \* FROM `voters` WHERE \(`id` IN \(1, 2\)\)/, sqls.shift)
+      assert_empty sqls
+    end
+  end
+end

data/test/support/active_record_setup.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+if RUBY_ENGINE == 'jruby'
+  require 'activerecord-jdbcsqlite3-adapter'
+else
+  require 'sqlite3'
+end
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+ActiveRecord::Schema.verbose = false
+ActiveRecord::Schema.define(version: 1) do
+  create_table :ballot_votes do |t|
+    t.references :votable, polymorphic: true
+    t.references :voter, polymorphic: true
+
+    t.boolean :vote
+    t.string :scope
+    t.integer :weight
+
+    t.timestamps null: false, default: 'now()'
+  end
+
+  add_index :ballot_votes, %i(voter_id voter_type scope)
+  add_index :ballot_votes, %i(votable_id votable_type scope)
+
+  %i(voters not_voters votables not_votables votable_voters).each do |table|
+    create_table table do |t|
+      t.string :name
+    end
+  end
+
+  %i(sti_votables sti_not_votables).each do |table|
+    create_table table do |t|
+      t.string :name
+      t.string :type
+    end
+  end
+
+  create_table :votable_caches do |t|
+    t.string :name
+
+    if t.respond_to?(:jsonb)
+      t.jsonb :cached_ballot_summary
+    else
+      t.string :cached_ballot_summary
+    end
+  end
+end
+
+require 'ballot/active_record'
+Ballot::ActiveRecord.inject!
+
+class ARVoter < ActiveRecord::Base
+  self.table_name = 'voters'
+  acts_as_ballot :voter
+end
+
+class ARNotVoter < ActiveRecord::Base
+  self.table_name = 'not_voters'
+end
+
+class ARVotable < ActiveRecord::Base
+  self.table_name = 'votables'
+  acts_as_ballot :votable
+end
+
+class ARNotVotable < ActiveRecord::Base
+  self.table_name = 'not_votables'
+end
+
+class ARVotableVoter < ActiveRecord::Base
+  self.table_name = 'votable_voters'
+  acts_as_ballot :voter
+  acts_as_ballot :votable
+end
+
+class ARStiVotable < ActiveRecord::Base
+  self.table_name = 'sti_votables'
+  acts_as_ballot :votable
+end
+
+class ARChildOfStiVotable < ARStiVotable
+end
+
+class ARStiNotVotable < ActiveRecord::Base
+  self.table_name = 'sti_not_votables'
+end
+
+class ARVotableChildOfStiNotVotable < ARStiNotVotable
+  acts_as_ballot :votable
+end
+
+class ARVotableCache < ActiveRecord::Base
+  self.table_name = 'votable_caches'
+  acts_as_ballot :votable
+end
+
+class ARABoringClass
+end
+
+class Minitest::ActiveRecordSpec < Minitest::HooksSpec
+  register_spec_type(/ActiveRecord|\AAR/, self)
+
+  AbortTransaction = Class.new(StandardError)
+
+  def around
+    ActiveRecord::Base.connection.transaction do
+      super
+      fail AbortTransaction
+    end
+  rescue AbortTransaction
+    true # This transaction has been deliberately aborted.
+  end
+
+  def votable_dataset(votable)
+    votable.ballots_for
+  end
+
+  def voter_dataset(voter)
+    voter.ballots_by
+  end
+
+  def ballot_type_name(item)
+    Ballot::ActiveRecord.type_name(item)
+  end
+
+  let(:voter) { ARVoter.create(name: 'I can vote!') }
+  let(:voter2) { ARVoter.create(name: 'I, too, can vote!') }
+  let(:not_voter) { ARNotVoter.create(name: 'I cannot vote!') }
+
+  let(:votable) { ARVotable.create(name: 'a votable model') }
+  let(:votable2) { ARVotable.create(name: 'a second votable model') }
+  let(:votable_cache) { ARVotableCache.create(name: 'a votable model with caching') }
+  let(:sti_votable) { ARStiVotable.create(name: 'a votable STI model') }
+  let(:child_of_sti_votable) {
+    ARChildOfStiVotable.create(name: 'a votable STI child model')
+  }
+  let(:votable_child_of_sti_not_votable) {
+    ARVotableChildOfStiNotVotable.create(name: 'a votable STI child of a non-votable')
+  }
+  let(:not_votable) { ARNotVotable.create(name: 'a non-votable model') }
+end

data/test/support/generators_setup.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+class Minitest::RailsGeneratorSpec < Minitest::HooksSpec
+  register_spec_type(/RailsGenerator/, self)
+
+  let(:app_path) { "test/generators/rails-#{orm_name}" }
+
+  def around
+    ENV['RAILS_VERSION'] = rails_version
+    ENV['ORM_VERSION'] = orm_version
+    gemfile = File.join(File.expand_path(app_path), 'Gemfile')
+
+    Dir.chdir(app_path) do
+      without_current_bundler do
+        ENV['BUNDLE_GEMFILE'] = gemfile
+        system! 'git clean -fdx .'
+        system! 'gem install bundler'
+        if ENV['TRAVIS']
+          system! 'bundle --version'
+          system! 'bundle install'
+        end
+        system! 'bundle exec rake db:create'
+        system! 'bundle exec rails g model votable name'
+        run_migrations!
+
+        yield
+      end
+    end
+  ensure
+    ENV.delete('ORM_VERSION')
+    ENV.delete('RAILS_VERSION')
+    ENV.delete('BUNDLE_GEMFILE')
+  end
+
+  def without_current_bundler(&block)
+    if defined?(::Bundler)
+      Bundler.with_clean_env(&block)
+    else
+      yield
+    end
+  end
+
+  def assert_subprocess_output(stdout = nil, stderr = nil)
+    out, err = capture_subprocess_io { yield }
+
+    err_msg = stderr.kind_of?(Regexp) ? :assert_match : :assert_equal if stderr
+    out_msg = stdout.kind_of?(Regexp) ? :assert_match : :assert_equal if stdout
+
+    y = send err_msg, stderr, err, 'In stderr' if err_msg
+    x = send out_msg, stdout, out, 'In stdout' if out_msg
+
+    (!stdout || x) && (!stderr || y)
+  end
+
+  def assert_contents(contents, filename)
+    contents_msg = contents.kind_of?(Regexp) ? :assert_match : :assert_equal
+    send contents_msg, contents, File.read(filename), 'In contents'
+  end
+
+  def run_migrations
+    system 'bundle exec rake db:migrate'
+  end
+
+  def run_migrations!
+    system! 'bundle exec rake db:migrate'
+  end
+
+  def system!(command)
+    output = capture_subprocess_io { system command }
+    fail output.join("\n") unless $?.success?
+  end
+
+  def rails_generate(*args)
+    system "bundle exec rails g #{args.join(' ')}"
+  end
+
+  class << self
+    def focus!
+      @focussed = true
+    end
+
+    def focussed?
+      !!@focussed
+    end
+
+    def test_ballot_install(generate: nil, migrate: nil, contents: nil)
+      return unless ENV['CI'] || ENV['TEST_GENERATORS']
+
+      fail 'Contents must be provided' unless contents
+
+      focus if focussed?
+      it 'installs the ballot_votes table' do
+        assert_subprocess_output generate || '' do
+          rails_generate 'ballot:install'
+        end
+
+        assert_subprocess_output migrate || '' do
+          run_migrations
+        end
+
+        assert_contents contents,
+          Dir['db/migrate/*_install_ballot_vote_migration.rb'].first
+      end
+    end
+
+    def test_ballot_summary_votable(generate: nil, migrate: nil, contents: nil)
+      return unless ENV['CI'] || ENV['TEST_GENERATORS']
+
+      fail 'Contents must be provided' unless contents
+
+      focus if focussed?
+      it 'adds the summary column to the votable table' do
+        assert_nil File.read('db/schema.rb').match(/cached_ballot_summary/)
+
+        assert_subprocess_output generate || '' do
+          rails_generate 'ballot:summary', 'votable'
+        end
+
+        assert_subprocess_output migrate || '' do
+          run_migrations
+        end
+
+        assert_contents contents,
+          Dir['db/migrate/*_ballot_cache_for_votable.rb'].first
+        assert_contents(/cached_ballot_summary/, 'db/schema.rb')
+      end
+    end
+  end
+end

data/test/support/sequel_setup.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'sequel'
+
+DB = if RUBY_ENGINE == 'jruby'
+       Sequel.connect('jdbc:sqlite::memory:')
+     else
+       Sequel.sqlite
+     end
+
+class SQLLogger
+  class << self
+    def sqls
+      Thread.current['sqls'] ||= []
+    end
+
+    def method_missing(_, msg)
+      sqls << msg
+    end
+
+    def clear
+      sqls.clear
+    end
+  end
+end
+
+DB.loggers << SQLLogger
+
+DB.create_table? :ballot_votes do
+  primary_key :id
+  Integer :votable_id
+  String :votable_type
+
+  Integer :voter_id
+  String :voter_type
+
+  Boolean :vote
+  String :scope
+  Integer :weight
+
+  DateTime :created_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+  DateTime :updated_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+end
+
+%i(voters not_voters votables not_votables votable_voters).each do |table|
+  DB.create_table? table do
+    primary_key :id
+    String :name
+  end
+end
+
+%i(sti_votables sti_not_votables).each do |table|
+  DB.create_table? table do
+    primary_key :id
+    String :name
+    String :type
+  end
+end
+
+DB.create_table? :votable_caches do
+  primary_key :id
+
+  String :name
+
+  if Sequel.respond_to?(:pg_json)
+    if respond_to?(:jsonb)
+      jsonb :cached_ballot_summary
+    else
+      json :cached_ballot_summary
+    end
+  else
+    String :cached_ballot_summary
+  end
+end
+
+require 'ballot/sequel'
+
+class SequelVoter < Sequel::Model(:voters)
+  plugin :ballot_voter
+end
+
+class SequelNotVoter < Sequel::Model(:not_voters)
+end
+
+class SequelVotable < Sequel::Model(:votables)
+  plugin :ballot_votable
+end
+
+class SequelNotVotable < Sequel::Model(:not_votables)
+end
+
+class SequelVotableVoter < Sequel::Model(:votable_voters)
+  plugin :ballot_voter
+  plugin :ballot_votable
+end
+
+class SequelStiVotable < Sequel::Model(:sti_votables)
+  plugin :single_table_inheritance, :type
+  plugin :ballot_votable
+end
+
+class SequelChildOfStiVotable < SequelStiVotable
+end
+
+class SequelStiNotVotable < Sequel::Model(:sti_not_votables)
+  plugin :single_table_inheritance, :type
+end
+
+class SequelVotableChildOfStiNotVotable < SequelStiNotVotable
+  plugin :ballot_votable
+end
+
+class SequelVotableCache < Sequel::Model(:votable_caches)
+  plugin :ballot_votable
+end
+
+class SequelABoringClass
+end
+
+class Minitest::SequelSpec < Minitest::HooksSpec
+  parallelize_me! unless RUBY_ENGINE == 'jruby'
+
+  register_spec_type(/Sequel/, self)
+
+  def around
+    Sequel::Model.db.transaction(rollback: :always, auto_savepoint: true) { super }
+  end
+
+  def capture_sql
+    SQLLogger.clear
+    yield
+    SQLLogger.sqls.dup
+  ensure
+    SQLLogger.clear
+  end
+
+  def votable_dataset(votable)
+    votable.ballots_for_dataset
+  end
+
+  def voter_dataset(voter)
+    voter.ballots_by_dataset
+  end
+
+  def ballot_type_name(item)
+    Ballot::Sequel.type_name(item)
+  end
+
+  let(:voter) { SequelVoter.create(name: 'I can vote!') }
+  let(:voter2) { SequelVoter.create(name: 'I, too, can vote!') }
+  let(:not_voter) { SequelNotVoter.create(name: 'I cannot vote!') }
+
+  let(:votable) { SequelVotable.create(name: 'a votable model') }
+  let(:votable2) { SequelVotable.create(name: 'a second votable model') }
+  let(:votable_cache) { SequelVotableCache.create(name: 'a votable model with caching') }
+  let(:sti_votable) { SequelStiVotable.create(name: 'a votable STI model') }
+  let(:child_of_sti_votable) {
+    SequelChildOfStiVotable.create(name: 'a votable STI child model')
+  }
+  let(:votable_child_of_sti_not_votable) {
+    SequelVotableChildOfStiNotVotable.create(name: 'a votable STI child of a non-votable')
+  }
+  let(:not_votable) { SequelNotVotable.create(name: 'a non-votable model') }
+end