object_id_gem 1.0.6

data/lib/objectid_columns/version.rb

@@ -0,0 +1,4 @@
+# What's the current version of this gem?
+module ObjectidColumns
+  VERSION = "1.0.6"
+end

data/object_id_gem.gemspec

@@ -0,0 +1,71 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'objectid_columns/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "object_id_gem"
+  spec.version       = ObjectidColumns::VERSION
+  spec.authors       = ["Andrew Geweke"]
+  spec.email         = ["ageweke@swiftype.com"]
+  spec.summary       = %q{Transparently store MongoDB ObjectId values in ActiveRecord.}
+  spec.homepage      = "https://www.github.com/swiftype/objectid_columns"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+
+  ar_version = ENV['OBJECTID_COLUMNS_AR_TEST_VERSION']
+  ar_version = ar_version.strip if ar_version
+
+  version_spec = case ar_version
+  when nil then [ ">= 5.0"]
+  when 'master' then nil
+  else [ "=#{ar_version}" ]
+  end
+
+  if version_spec
+    spec.add_dependency("activerecord", *version_spec)
+    spec.add_dependency("activesupport", *version_spec)
+  end
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.14"
+  spec.add_development_dependency "moped", "~> 1.5" unless RUBY_VERSION =~ /^1\.8\./
+  spec.add_development_dependency "bson", "~> 1.9"
+
+  require File.expand_path(File.join(File.dirname(__FILE__), 'spec', 'objectid_columns', 'helpers', 'database_helper'))
+  database_gem_name = ObjectidColumns::Helpers::DatabaseHelper.maybe_database_gem_name
+
+  # Ugh. Later versions of the 'mysql2' gem are incompatible with AR 3.0.x; so, here, we explicitly trap that case
+  # and use an earlier version of that Gem.
+  if database_gem_name && database_gem_name == 'mysql2' && ar_version && ar_version =~ /^3\.0\./
+    spec.add_development_dependency('mysql2', '~> 0.2.0')
+  else
+    spec.add_development_dependency(database_gem_name)
+  end
+
+  # Double ugh. Basically, composite_primary_keys -- as useful as it is! -- is also incredibly incompatible with so
+  # much stuff:
+  #
+  # * Under Ruby 1.9+ with Postgres, it causes binary strings sent to or from the database to get truncated
+  #   at the first null byte (!), which completely breaks binary-column support;
+  # * Under JRuby with ActiveRecord 3.0, it's completely broken;
+  # * Under JRuby with ActiveRecord 3.1 and PostgreSQL, it's also broken.
+  #
+  # In these cases, we simply don't load or test against composite_primary_keys; our code is good, but the interactions
+  # between CPK and the rest of the system make it impossible to run those tests. There is corresponding code in our
+  # +basic_system_spec+ to exclude those combinations.
+  cpk_allowed = true
+  cpk_allowed = false if database_gem_name =~ /(pg|postgres)/i && RUBY_VERSION =~ /^(1\.9)|(2\.)/ && ar_version && ar_version =~ /^4\.(0|1)\./
+  cpk_allowed = false if defined?(RUBY_ENGINE) && (RUBY_ENGINE == 'jruby') && ar_version && ar_version =~ /^3\.0\./
+  cpk_allowed = false if defined?(RUBY_ENGINE) && (RUBY_ENGINE == 'jruby') && ar_version && ar_version =~ /^3\.1\./ && database_gem_name =~ /(pg|postgres)/i
+
+  if cpk_allowed
+    spec.add_development_dependency "composite_primary_keys"
+  end
+end

data/spec/objectid_columns/helpers/database_helper.rb

@@ -0,0 +1,178 @@
+module ObjectidColumns
+  module Helpers
+    class DatabaseHelper
+      class InvalidDatabaseConfigurationError < StandardError; end
+
+      class << self
+        def maybe_database_gem_name
+          begin
+            dh = new
+            dh.database_gem_name
+          rescue InvalidDatabaseConfigurationError => idce
+            nil
+          end
+        end
+      end
+
+      def initialize
+        config # make sure we raise on instantiation if configuration is invalid
+      end
+
+      def database_type
+        case database_gem_name
+        when /mysql/i then :mysql
+        when /sqlite/i then :sqlite
+        when /pg/i, /postgres/i then :postgres
+        else raise "Unknown database type for Gem name: #{database_gem_name.inspect}"
+        end
+      end
+
+      def setup_activerecord!
+        require 'active_record'
+        require config[:require]
+        ::ActiveRecord::Base.establish_connection(config[:config])
+
+        require 'logger'
+        require 'stringio'
+        @logs = StringIO.new
+        ::ActiveRecord::Base.logger = Logger.new(@logs)
+
+        if config[:config][:adapter] == 'sqlite3'
+          sqlite_version = ::ActiveRecord::Base.connection.send(:sqlite_version).instance_variable_get("@version").inspect rescue "unknown"
+        end
+      end
+
+      def table_name(name)
+        "objectidcols_spec_#{name}"
+      end
+
+      def database_gem_name
+        config[:database_gem_name]
+      end
+
+      def adapter_name
+        config[:config][:adapter]
+      end
+
+      private
+      def config
+        config_from_config_file || travis_ci_config_from_environment || invalid_config_file!
+      end
+
+      def config_from_config_file
+        return nil unless File.exist?(config_file_path)
+        require config_file_path
+
+        return nil unless defined?(OBJECTID_COLUMNS_SPEC_DATABASE_CONFIG)
+        return nil unless OBJECTID_COLUMNS_SPEC_DATABASE_CONFIG.kind_of?(Hash)
+
+        return nil unless OBJECTID_COLUMNS_SPEC_DATABASE_CONFIG[:require]
+        return nil unless OBJECTID_COLUMNS_SPEC_DATABASE_CONFIG[:database_gem_name]
+
+        return nil unless OBJECTID_COLUMNS_SPEC_DATABASE_CONFIG
+        OBJECTID_COLUMNS_SPEC_DATABASE_CONFIG
+      end
+
+      def travis_ci_config_from_environment
+        dbtype = (ENV['OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE'] || '').strip.downcase
+        is_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+        if is_jruby
+          case dbtype
+          when 'mysql'
+            {
+              :require => 'activerecord-jdbcmysql-adapter',
+              :database_gem_name => 'activerecord-jdbcmysql-adapter',
+              :config => {
+                :adapter => 'jdbcmysql',
+                :database => 'myapp_test',
+                :username => 'travis',
+                :encoding => 'utf8'
+              }
+            }
+          when 'postgres', 'postgresql'
+            {
+              :require => 'activerecord-jdbcpostgresql-adapter',
+              :database_gem_name => 'activerecord-jdbcpostgresql-adapter',
+              :config => {
+                :adapter => 'jdbcpostgresql',
+                :database => 'myapp_test',
+                :username => 'postgres'
+              }
+            }
+          when 'sqlite'
+            {
+              :require => 'activerecord-jdbcsqlite3-adapter',
+              :database_gem_name => 'activerecord-jdbcsqlite3-adapter',
+              :config => {
+                :adapter => 'jdbcsqlite3',
+                :database => ':memory:'
+              }
+            }
+          when '', nil then nil
+          else
+            raise "Unknown Travis CI database type: #{dbtype.inspect}"
+          end
+        else
+          case dbtype
+          when 'postgres', 'postgresql'
+            {
+              :require => 'pg',
+              :database_gem_name => 'pg',
+              :config => {
+                :adapter => 'postgresql',
+                :database => 'myapp_test',
+                :username => 'postgres',
+                :min_messages => 'WARNING'
+              }
+            }
+          when 'mysql'
+            {
+              :require => 'mysql2',
+              :database_gem_name => 'mysql2',
+              :config => {
+                :adapter => 'mysql2',
+                :database => 'myapp_test',
+                :username => 'travis',
+                :encoding => 'utf8'
+              }
+            }
+          when 'sqlite'
+            {
+              :require => 'sqlite3',
+              :database_gem_name => 'sqlite3',
+              :config => {
+                :adapter => 'sqlite3',
+                :database => ':memory:',
+                :timeout => 500
+              }
+            }
+          when '', nil then nil
+          else
+            raise "Unknown Travis CI database type: #{dbtype.inspect}"
+          end
+        end
+      end
+
+      def config_file_path
+        @config_file_path ||= File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_database_config.rb'))
+      end
+
+      def invalid_config_file!
+        raise Errno::ENOENT, %{In order to run specs for ObjectIdColumns, you need to create a file at:
+
+#{config_file_path}
+
+...that defines a top-level OBJECTID_COLUMNS_SPEC_DATABASE_CONFIG hash, with members:
+
+  :require => 'name_of_adapter_to_require',
+  :database_gem_name => 'name_of_gem_for_adapter',
+  :config  => { ...whatever ActiveRecord::Base.establish_connection should be passed... }
+
+Alternatively, if you're running under Travis CI, you can set the environment variable
+OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE to 'postgres', 'mysql', or 'sqlite', and it will
+use the correct configuration for testing on Travis CI.}
+      end
+    end
+  end
+end

data/spec/objectid_columns/helpers/system_helpers.rb

@@ -0,0 +1,92 @@
+require 'active_record'
+require 'active_record/migration'
+require 'objectid_columns/helpers/database_helper'
+
+module ObjectidColumns
+  module Helpers
+    module SystemHelpers
+      def migrate(&block)
+        migration_class = Class.new(::ActiveRecord::Migration)
+        metaclass = migration_class.class_eval { class << self; self; end }
+        metaclass.instance_eval { define_method(:up, &block) }
+
+        ::ActiveRecord::Migration.suppress_messages do
+          migration_class.migrate(:up)
+        end
+      end
+
+      def define_model_class(name, table_name, options = { }, &block)
+        superclass = options[:superclass] || ::ActiveRecord::Base
+        model_class = Class.new(superclass)
+        ::Object.send(:remove_const, name) if ::Object.const_defined?(name)
+        ::Object.const_set(name, model_class)
+        model_class.table_name = table_name if table_name
+        model_class.class_eval(&block) if block
+        model_class
+      end
+
+      def ensure_database_is_set_up!
+        ::ObjectidColumns::Helpers::SystemHelpers.database_helper
+      end
+
+      class << self
+        def database_helper
+          @database_helper ||= begin
+            out = ObjectidColumns::Helpers::DatabaseHelper.new
+            out.setup_activerecord!
+            out
+          end
+        end
+
+        def binary_column(length)
+          case ObjectidColumns::Helpers::SystemHelpers.database_helper.adapter_name.to_s
+          when /mysql/, /sqlite/ then "BINARY(#{length})"
+          when /postgres/ then "BYTEA"
+          else raise "Don't yet know how to define a binary column for database #{OBJECTID_COLUMNS_SPEC_DATABASE_CONFIG[:config][:adapter].inspect}"
+          end
+        end
+
+        def supports_length_limits_on_binary_columns?
+          case ObjectidColumns::Helpers::SystemHelpers.database_helper.adapter_name.to_s
+          when /mysql/, /sqlite/ then true
+          when /postgres/ then false
+          else raise "Don't yet know whether database #{OBJECTID_COLUMNS_SPEC_DATABASE_CONFIG[:config][:adapter].inspect} supports limits on binary columns"
+          end
+        end
+      end
+
+      def create_standard_system_spec_tables!
+        migrate do
+          drop_table :objectidcols_spec_table rescue nil
+          create_table :objectidcols_spec_table do |t|
+            t.column :perfect_b_oid, ObjectidColumns::Helpers::SystemHelpers.binary_column(12)
+            t.column :longer_b_oid, ObjectidColumns::Helpers::SystemHelpers.binary_column(15)
+
+            t.column :too_short_b, ObjectidColumns::Helpers::SystemHelpers.binary_column(11)
+            t.column :perfect_b, ObjectidColumns::Helpers::SystemHelpers.binary_column(12)
+            t.column :longer_b, ObjectidColumns::Helpers::SystemHelpers.binary_column(15)
+
+            t.column :perfect_s_oid, 'VARCHAR(24)'
+            t.column :longer_s_oid, 'VARCHAR(30)'
+
+            t.column :too_short_s, 'VARCHAR(23)'
+            t.column :perfect_s, 'VARCHAR(24)'
+            t.column :longer_s, 'VARCHAR(30)'
+
+            t.integer :some_int_column
+          end
+        end
+      end
+
+      def create_standard_system_spec_models!
+        define_model_class(:Spectable, 'objectidcols_spec_table') { }
+      end
+
+      def drop_standard_system_spec_tables!
+        migrate do
+          drop_table :objectidcols_spec_table rescue nil
+        end
+      end
+    end
+  end
+end

data/spec/objectid_columns/system/basic_system_spec.rb

@@ -0,0 +1,600 @@
+require 'objectid_columns'
+require 'objectid_columns/helpers/system_helpers'
+
+# See the gemspec for more details -- basically, we don't always load composite_primary_keys, because it's pretty
+# broken and doesn't work with a fair number of combinations of Ruby versions, databases, and so on. So if it's not
+# available, we skip those tests.
+begin
+  require 'composite_primary_keys'
+  $composite_primary_keys_available = true
+rescue LoadError => le
+  # nothing here
+end
+
+unless defined?(VALID_OBJECTID_CLASSES)
+  VALID_OBJECTID_CLASSES = [ BSON::ObjectId ]
+  VALID_OBJECTID_CLASSES << Moped::BSON::ObjectId if defined?(Moped::BSON::ObjectId)
+end
+
+RSpec::Matchers.define :be_an_objectid_object do
+  match do |actual|
+    VALID_OBJECTID_CLASSES.detect { |c| actual.kind_of?(c) }
+  end
+  failure_message_for_should do |actual|
+    "expected that #{actual} (#{actual.class}) would be an instance of BSON::ObjectId or Moped::BSON::ObjectId"
+  end
+end
+
+RSpec::Matchers.define :be_the_same_objectid_as do |expected|
+  match do |actual|
+    net_expected = expected ? expected.to_bson_id.to_s : expected
+    net_actual = actual ? actual.to_bson_id.to_s : actual
+    net_expected == net_actual
+  end
+  failure_message_for_should do |actual|
+    "expected that #{actual} (#{actual.class}) would be the same ObjectId as #{expected} (#{expected.class})"
+  end
+end
+
+RSpec::Matchers.define :be_an_objectid_object_matching do |expected|
+  match do |actual|
+    net_expected = expected ? expected.to_bson_id.to_s : expected
+    net_actual = actual ? actual.to_bson_id.to_s : actual
+    (net_expected == net_actual) && (VALID_OBJECTID_CLASSES.detect { |c| actual.kind_of?(c) })
+  end
+  failure_message_for_should do |actual|
+    "expected that #{actual} (#{actual.class}) would be an ObjectId object equal to #{expected} (#{expected.class})"
+  end
+end
+
+describe "ObjectidColumns basic operations" do
+  include ObjectidColumns::Helpers::SystemHelpers
+
+  before :each do
+    ensure_database_is_set_up!
+
+    create_standard_system_spec_tables!
+    create_standard_system_spec_models!
+  end
+
+  after :each do
+    drop_standard_system_spec_tables!
+  end
+
+  VALID_OBJECTID_CLASSES.each do |test_class|
+    context "using test class #{test_class}" do
+      before :each do
+        @tc = test_class
+      end
+
+      def new_oid
+        @tc.new
+      end
+
+      context "with an STI table and model" do
+        before :each do
+          migrate do
+            drop_table :objectidcols_spec_table_sti rescue nil
+            create_table :objectidcols_spec_table_sti do |t|
+              t.string :type
+              t.column :some_oid, 'VARCHAR(24)'
+            end
+          end
+        end
+
+        after :each do
+          migrate do
+            drop_table :objectidcols_spec_table_sti rescue nil
+          end
+        end
+
+        let(:parent_model_class) { define_model_class(:SpectableStiParent, 'objectidcols_spec_table_sti') { has_objectid_columns } }
+        let(:child_model_class) { define_model_class(:SpectableStiChild, 'objectidcols_spec_table_sti', :superclass => parent_model_class) { } }
+
+        it "should work from both the parent and child class" do
+          id_1 = new_oid
+          id_2 = new_oid
+
+          parent_instance = parent_model_class.new(:some_oid => id_1)
+          parent_instance.save!
+
+          child_instance = child_model_class.new(:some_oid => id_2)
+          child_instance.save!
+
+          all_models = parent_model_class.all.to_a
+          expect(all_models.length).to eq(2)
+          parent_instance_again = all_models.detect { |m| m.id == parent_instance.id }
+          child_instance_again = all_models.detect { |m| m.id == child_instance.id }
+
+          expect(parent_instance_again.some_oid).to be_an_objectid_object_matching(id_1)
+          expect(child_instance_again.some_oid).to be_an_objectid_object_matching(id_2)
+
+          child_models = child_model_class.all.to_a
+          expect(child_models.length).to eq(1)
+          expect(child_models[0].some_oid).to be_an_objectid_object_matching(id_2)
+        end
+      end
+
+      it "should not allow defining a column that's too short" do
+        if ObjectidColumns::Helpers::SystemHelpers.supports_length_limits_on_binary_columns?
+          expect { ::Spectable.class_eval { has_objectid_column :too_short_b } }.to raise_error(ArgumentError)
+          expect { ::Spectable.class_eval { has_objectid_column :too_short_s } }.to raise_error(ArgumentError)
+        end
+      end
+
+      it "should not allow defining a column that's the wrong type" do
+        expect { ::Spectable.class_eval { has_objectid_column :some_int_column } }.to raise_error(ArgumentError)
+      end
+
+      it "should not allow defining a column that doesn't exist" do
+        expect { ::Spectable.class_eval { has_objectid_column :unknown_column } }.to raise_error(ArgumentError)
+      end
+
+      it "should not fail if the table doesn't exist" do
+        define_model_class(:SpectableNonexistent, 'objectidcols_spec_table_nonexistent') { }
+        expect { ::SpectableNonexistent.class_eval { has_objectid_column :foo } }.to_not raise_error
+      end
+
+      it "should not fail if declared as a primary key and the table doesn't exist" do
+        define_model_class(:SpectableNonexistent, 'objectidcols_spec_table_nonexistent') { }
+        expect { ::SpectableNonexistent.class_eval { has_objectid_primary_key } }.to_not raise_error
+        expect { ::SpectableNonexistent.class_eval { has_objectid_primary_key :foo } }.to_not raise_error
+      end
+
+      if $composite_primary_keys_available
+        describe "composite primary key support" do
+          context "with an implicit PK" do
+            before :each do
+              migrate do
+                drop_table :objectidcols_spec_pk_cmp rescue nil
+                create_table :objectidcols_spec_pk_cmp, :id => false do |t|
+                  t.binary :some_oid, :null => false
+                  t.string :more_pk, :null => false
+                  t.string :value
+                end
+              end
+
+              define_model_class(:SpectablePkCmp, :objectidcols_spec_pk_cmp) do
+                if respond_to?(:primary_keys=)
+                  self.primary_keys = [ 'some_oid', 'more_pk' ]
+                else
+                  self.set_primary_keys('some_oid', 'more_pk')
+                end
+              end
+              ::SpectablePkCmp.class_eval { has_objectid_primary_key }
+              @model_class = ::SpectablePkCmp
+            end
+
+            it "should allow using a composite primary key in individual parts" do
+              pending "disabled" unless $composite_primary_keys_available
+
+              instance = @model_class.new
+              instance.some_oid = new_oid
+              instance.more_pk = "foo"
+              instance.value = "foo value"
+              instance.save!
+
+              instance_again = @model_class.find([ instance.some_oid, instance.more_pk ])
+              expect(instance_again.value).to eq(instance.value)
+              expect(instance_again.some_oid).to eq(instance.some_oid)
+              expect(instance_again.more_pk).to eq(instance.more_pk)
+            end
+
+            it "should allow using a composite primary key as a whole" do
+              pending "disabled" unless $composite_primary_keys_available
+
+              oid = new_oid
+              instance = @model_class.new
+              instance.id = [ oid, "foo" ]
+              instance.value = "foo value"
+              instance.save!
+
+              expect(instance.some_oid).to be_an_objectid_object_matching(oid)
+              expect(instance.more_pk).to eq("foo")
+              expect(instance.value).to eq("foo value")
+
+              instance_again = @model_class.find(instance.id)
+              expect(instance_again.id).to eq(instance.id)
+              expect(instance_again.some_oid).to be_an_objectid_object_matching(oid)
+              expect(instance_again.more_pk).to eq("foo")
+              expect(instance_again.value).to eq("foo value")
+              expect(instance_again.id).to be_kind_of(Array)
+              expect(instance_again.id.length).to eq(2)
+              expect(instance_again.id[0]).to be_an_objectid_object_matching(oid)
+              expect(instance_again.id[1]).to eq("foo")
+            end
+          end
+
+          context "with an explicit PK" do
+            before :each do
+              migrate do
+                drop_table :objectidcols_spec_pk_cmp_2 rescue nil
+                create_table :objectidcols_spec_pk_cmp_2, :id => false do |t|
+                  t.binary :one, :null => false
+                  t.string :two, :null => false
+                  t.string :three, :null => false
+                  t.string :value
+                end
+              end
+
+              define_model_class(:SpectablePkCmp2, :objectidcols_spec_pk_cmp_2) do
+                if respond_to?(:primary_keys=)
+                  self.primary_keys = [ 'one', 'two', 'three' ]
+                else
+                  self.set_primary_keys('one', 'two', 'three')
+                end
+              end
+              ::SpectablePkCmp2.class_eval { has_objectid_primary_key :one, :three }
+              @model_class = ::SpectablePkCmp2
+            end
+
+            it "should allow using a composite primary key that's partially ObjectId and partially not" do
+              instance = @model_class.new
+              instance.two = "foo"
+              instance.value = "foo_value"
+              instance.save!
+
+              expect(instance.id).to be_kind_of(Array)
+              expect(instance.id[0]).to be_an_objectid_object
+              expect(instance.id[1]).to eq("foo")
+              expect(instance.id[2]).to be_an_objectid_object
+
+              id = instance.id
+              instance_again = @model_class.find(id)
+              expect(instance_again.id).to eq(id)
+              expect(instance_again.id[0]).to be_an_objectid_object_matching(id[0])
+              expect(instance_again.id[1]).to eq("foo")
+              expect(instance_again.id[2]).to be_an_objectid_object_matching(id[2])
+            end
+          end
+        end
+      end
+
+      describe "primary key column support" do
+        before :each do
+          migrate do
+            drop_table :objectidcols_spec_pk_bin rescue nil
+            create_table :objectidcols_spec_pk_bin, :id => false do |t|
+              t.binary :id, :null => false
+              t.string :name
+            end
+
+            drop_table :objectidcols_spec_pk_str rescue nil
+            create_table :objectidcols_spec_pk_str, :id => false do |t|
+              t.string :id, :null => false
+              t.string :name
+            end
+
+            drop_table :objectidcols_spec_pk_alt rescue nil
+            create_table :objectidcols_spec_pk_alt, :id => false do |t|
+              t.binary :some_name, :null => false
+              t.string :name
+            end
+
+            drop_table :objectidcols_spec_pk_implicit rescue nil
+            create_table :objectidcols_spec_pk_implicit, :id => false do |t|
+              t.binary :some_name, :null => false
+              t.string :name
+            end
+          end
+
+          define_model_class(:SpectablePkBin, :objectidcols_spec_pk_bin) { self.primary_key = 'id' }
+          define_model_class(:SpectablePkStr, :objectidcols_spec_pk_str) { self.primary_key = 'id' }
+          define_model_class(:SpectablePkAlt, :objectidcols_spec_pk_alt) { self.primary_key = 'some_name' }
+          define_model_class(:SpectablePkImplicit, :objectidcols_spec_pk_implicit) { }
+
+          ::SpectablePkBin.class_eval { has_objectid_primary_key }
+          ::SpectablePkStr.class_eval { has_objectid_primary_key }
+          ::SpectablePkAlt.class_eval { has_objectid_primary_key }
+          ::SpectablePkImplicit.class_eval { has_objectid_primary_key :some_name }
+        end
+
+        after :each do
+          drop_table :objectidcols_spec_pk_bin rescue nil
+          drop_table :objectidcols_spec_pk_str rescue nil
+          drop_table :objectidcols_spec_pk_table_alt rescue nil
+          drop_table :objectidcols_spec_pk_implicit rescue nil
+        end
+
+        [ :SpectablePkBin, :SpectablePkStr, :SpectablePkAlt, :SpectablePkImplicit ].each do |model_class|
+          context "on model #{model_class}" do
+            before :each do
+              @model_class = model_class.to_s.constantize
+            end
+
+            it "should fail autodetection, since there are no columns ending in _oid" do
+              expect { @model_class.has_objectid_columns }.to raise_error(ArgumentError)
+            end
+
+            it "should allow using a binary ObjectId column as a primary key" do
+              r1 = @model_class.new
+              r1.name = 'row 1'
+              expect(r1.id).to be_nil
+              r1.save!
+              expect(r1.id).to_not be_nil
+              expect(r1.id).to be_an_objectid_object
+              r1_id = r1.id
+
+              r2 = @model_class.new
+              r2.name = 'row 2'
+              expect(r2.id).to be_nil
+              r2.save!
+              expect(r2.id).to_not be_nil
+              expect(r2.id).to be_an_objectid_object
+              r2_id = r2.id
+
+              expect(r1.send(@model_class.primary_key)).to be_an_objectid_object_matching(r1.id)
+              expect(r2.send(@model_class.primary_key)).to be_an_objectid_object_matching(r2.id)
+
+              r1_again = @model_class.find(r1.id)
+              expect(r1_again.name).to eq('row 1')
+
+              r2_again = @model_class.find(r2.id)
+              expect(r2_again.name).to eq('row 2')
+
+              expect(@model_class.find([ r1.id, r2. id ]).map(&:id).sort_by(&:to_s)).to eq([ r1_id, r2_id ].sort_by(&:to_s))
+
+              expect(@model_class.where(:name => 'row 1').first.id).to eq(r1_id)
+              expect(@model_class.where(:name => 'row 2').first.id).to eq(r2_id)
+
+              find_by_id_method = "find_by_#{@model_class.primary_key}"
+              expect(@model_class.send(find_by_id_method, r1.id).id).to eq(r1_id)
+              expect(@model_class.send(find_by_id_method, r2.id).id).to eq(r2_id)
+              expect(@model_class.send(find_by_id_method, new_oid)).to be_nil
+            end
+
+            it "should let you load and save objects properly" do
+              r1 = @model_class.new
+              r1.name = 'row 1'
+              r1.id = new_oid
+              r1.save!
+
+              r1_again = @model_class.find(@tc.from_string(r1.id.to_s))
+              expect(r1_again.name).to eq('row 1')
+              r1_again.id = @tc.from_string(r1.id.to_s)
+              r1_again.name = 'row 1 again'
+              r1_again.save!
+
+              r1_yet_again = @model_class.find(r1_again.id)
+              expect(r1_yet_again.name).to eq('row 1 again')
+            end
+
+            it "should not pick up primary-key columns automatically, even if they're named _oid" do
+              migrate do
+                drop_table :objectidcols_spec_pk_auto rescue nil
+                create_table :objectidcols_spec_pk_auto, :id => false do |t|
+                  t.binary :foo_oid, :null => false
+                  t.binary :bar_oid
+                  t.string :name
+                end
+              end
+
+              define_model_class(:SpectablePkAuto, :objectidcols_spec_pk_auto) { self.primary_key = 'foo_oid' }
+
+              ::SpectablePkAuto.has_objectid_columns
+              r = ::SpectablePkAuto.new
+              r.foo_oid = 'foobar' # this will only work if we do NOT think it's an ObjectId
+              expect { r.bar_oid = 'foobar' }.to raise_error(ArgumentError)
+              r.bar_oid = the_bar_oid = new_oid.to_s
+
+              expect(r.bar_oid).to be_an_objectid_object_matching(the_bar_oid)
+
+              migrate do
+                drop_table :objectidcols_spec_pk_auto rescue nil
+              end
+            end
+          end
+        end
+      end
+
+      context "with a single, manually-defined column" do
+        before :each do
+          ::Spectable.class_eval { has_objectid_column :perfect_s_oid }
+        end
+
+        it "should allow writing and reading via an ObjectId object" do
+          the_oid = new_oid
+
+          r = ::Spectable.new
+          r.perfect_s_oid = the_oid
+          expect(r.perfect_s_oid).to be_the_same_objectid_as(the_oid)
+          expect(r.perfect_s_oid).to be_an_objectid_object
+          r.save!
+          expect(r.perfect_s_oid).to be_the_same_objectid_as(the_oid.to_s)
+          expect(r.perfect_s_oid).to be_an_objectid_object
+
+          r_again = ::Spectable.find(r.id)
+          expect(r_again.perfect_s_oid).to be_the_same_objectid_as(the_oid.to_s)
+          expect(r_again.perfect_s_oid).to be_an_objectid_object
+        end
+
+        it "should raise a good exception if you try to assign something that isn't a valid ObjectId" do
+          r = ::Spectable.new
+
+          expect { r.perfect_s_oid = 12345 }.to raise_error(ArgumentError, /12345/)
+          expect { r.perfect_s_oid = /foobar/ }.to raise_error(ArgumentError, /foobar/i)
+        end
+
+        if "".respond_to?(:encoding)
+          it "should not allow assigning binary strings unless their encoding is BINARY" do
+            r = ::Spectable.new
+
+            binary = new_oid.to_binary
+            binary = binary.force_encoding(Encoding::ISO_8859_1)
+            expect { r.perfect_s_oid = binary }.to raise_error(ArgumentError)
+          end
+        end
+
+        it "should not allow assigning strings that are the wrong format" do
+          r = ::Spectable.new
+
+          expect { r.perfect_s_oid = new_oid.to_binary[0..10] }.to raise_error(ArgumentError)
+          expect { r.perfect_s_oid = new_oid.to_binary + "\x00" }.to raise_error(ArgumentError)
+        end
+
+        it "should let you set columns to nil" do
+          r = ::Spectable.create!(:perfect_s_oid => (@oid = new_oid))
+
+          r_again = ::Spectable.find(r.id)
+          expect(r_again.perfect_s_oid).to be_an_objectid_object_matching(@oid)
+          r.perfect_s_oid = nil
+          r.save!
+
+          r_yet_again = ::Spectable.find(r.id)
+          expect(r_yet_again.perfect_s_oid).to be_nil
+        end
+
+        it "should accept ObjectIds for input in binary, String, or either object format" do
+          VALID_OBJECTID_CLASSES.each do |klass|
+            r = ::Spectable.create!(:perfect_s_oid => (@oid = klass.new))
+            expect(::Spectable.find(r.id).perfect_s_oid).to be_an_objectid_object_matching(@oid)
+          end
+
+          r = ::Spectable.create!(:perfect_s_oid => (@oid = new_oid.to_s))
+          expect(::Spectable.find(r.id).perfect_s_oid).to be_an_objectid_object_matching(@oid)
+
+          r = ::Spectable.create!(:perfect_s_oid => (@oid = new_oid.to_binary))
+          expect(::Spectable.find(r.id).perfect_s_oid).to be_an_objectid_object_matching(@oid)
+        end
+
+        it "should not do anything to the other columns" do
+          r = ::Spectable.new
+
+          r.perfect_b_oid = 'perfect_b_1'
+          r.longer_b_oid = 'longer_b_1'
+
+          r.too_short_b = 'short_b_2'
+          r.perfect_b = 'perfect_b_2'
+          r.longer_b = 'longer_b_2'
+
+          the_oid = new_oid
+          r.perfect_s_oid = the_oid
+          r.longer_s_oid = 'longer_s_1'
+
+          r.too_short_s = 'short_s_1'
+          r.perfect_s = 'perfect_s_2'
+          r.longer_s = 'longer_s'
+
+          r.save!
+
+          r_again = ::Spectable.find(r.id)
+
+          expect(r_again.perfect_b_oid.strip).to eq('perfect_b_1')
+          expect(r_again.longer_b_oid.strip).to eq('longer_b_1')
+
+          expect(r_again.too_short_b.strip).to eq('short_b_2')
+          expect(r_again.perfect_b.strip).to eq('perfect_b_2')
+          expect(r_again.longer_b.strip).to eq('longer_b_2')
+
+          expect(r_again.perfect_s_oid).to be_the_same_objectid_as(the_oid)
+          expect(r_again.perfect_s_oid).to be_an_objectid_object
+          expect(r_again.longer_s_oid).to eq('longer_s_1')
+
+          expect(r_again.too_short_s).to eq('short_s_1')
+          expect(r_again.perfect_s).to eq('perfect_s_2')
+          expect(r_again.longer_s).to eq('longer_s')
+        end
+
+        it "should allow querying on ObjectId columns via Hash, but not change other queries" do
+          r1 = ::Spectable.create!(:perfect_s_oid => (@oid1 = new_oid), :longer_s_oid => "foobar")
+          r2 = ::Spectable.create!(:perfect_s_oid => (@oid2 = new_oid), :longer_s_oid => "barfoo")
+
+          expect(::Spectable.where(:perfect_s_oid => @oid1).to_a.map(&:id)).to eq([ r1.id ])
+          expect(::Spectable.where(:perfect_s_oid => @oid2).to_a.map(&:id)).to eq([ r2.id ])
+          expect(::Spectable.where(:perfect_s_oid => [ @oid1, @oid2 ]).to_a.map(&:id).sort).to eq([ r1.id, r2.id ].sort)
+
+          expect(::Spectable.where(:perfect_s_oid => @oid1.to_s).to_a.map(&:id)).to eq([ r1.id ])
+          expect(::Spectable.where(:perfect_s_oid => @oid2.to_s).to_a.map(&:id)).to eq([ r2.id ])
+          expect(::Spectable.where(:perfect_s_oid => [ @oid1, @oid2 ].map(&:to_s)).to_a.map(&:id).sort).to eq([ r1.id, r2.id ].sort)
+
+          expect(::Spectable.where(:perfect_s_oid => @oid1.to_binary).to_a.map(&:id)).to eq([ r1.id ])
+          expect(::Spectable.where(:perfect_s_oid => @oid2.to_binary).to_a.map(&:id)).to eq([ r2.id ])
+          expect(::Spectable.where(:perfect_s_oid => [ @oid1, @oid2 ].map(&:to_binary)).to_a.map(&:id).sort).to eq([ r1.id, r2.id ].sort)
+        end
+
+        it "should give a good exception if you try to pass an ObjectID for a column that isn't an official ObjectID column" do
+          oid = new_oid
+          expect { ::Spectable.where(:perfect_b_oid => oid).to_a }.to raise_error(/ObjectidColumns:.*perfect_b_oid/mi)
+        end
+
+        it "should not blow up (and instead let ActiveRecord blow up) if you try to pass an ObjectID for a column that isn't a column at all" do
+          oid = new_oid
+          expect { ::Spectable.where(:something => oid).to_a }.to raise_error(/something/mi)
+        end
+
+        it "should not blow up (and instead let ActiveRecord just find no records, or blow up) if you try to pass an ObjectID for a column on a table that isn't using this gem at all" do
+          define_model_class(:SpectableNondeclared, 'objectidcols_spec_table') { }
+          expect(::SpectableNondeclared.where(:perfect_s_oid => new_oid).to_a).to eq([ ])
+
+          expect { ::SpectableNondeclared.where(:something => new_oid).to_a }.to raise_error(/something/i)
+        end
+      end
+
+      it "should allow using any column that's long enough, including binary or string columns" do
+        ::Spectable.class_eval do
+          has_objectid_columns :perfect_b_oid, :longer_b_oid
+          has_objectid_columns :perfect_s_oid, :longer_s_oid, :perfect_s, :longer_s
+        end
+
+        r = ::Spectable.new
+
+        r.perfect_b_oid = @perfect_b_oid = new_oid
+        r.longer_b_oid = @longer_b_oid = new_oid
+        r.perfect_s_oid = @perfect_s_oid = new_oid
+        r.longer_s_oid = @longer_s_oid = new_oid
+        r.perfect_s = @perfect_s = new_oid
+        r.longer_s = @longer_s = new_oid
+
+        r.save!
+
+        r_again = ::Spectable.find(r.id)
+        expect(r_again.perfect_b_oid).to be_an_objectid_object_matching(@perfect_b_oid)
+        expect(r_again.longer_b_oid).to be_an_objectid_object_matching(@longer_b_oid)
+        expect(r_again.perfect_s_oid).to be_an_objectid_object_matching(@perfect_s_oid)
+        expect(r_again.longer_s_oid).to be_an_objectid_object_matching(@longer_s_oid)
+        expect(r_again.perfect_s).to be_an_objectid_object_matching(@perfect_s)
+        expect(r_again.longer_s).to be_an_objectid_object_matching(@longer_s)
+      end
+
+      it "should automatically pick up any _oid columns" do
+        ::Spectable.class_eval do
+          has_objectid_columns
+        end
+
+        r = ::Spectable.new
+
+        r.perfect_b_oid = @perfect_b_oid = new_oid
+        r.longer_b_oid = @longer_b_oid = new_oid
+
+        r.too_short_b = 'short_b_2'
+        r.perfect_b = 'perfect_b_2'
+        r.longer_b = 'longer_b_2'
+
+        r.perfect_s_oid = @perfect_s_oid = new_oid
+        r.longer_s_oid = @longer_s_oid = new_oid
+
+        r.too_short_s = 'short_s_1'
+        r.perfect_s = 'perfect_s_2'
+        r.longer_s = 'longer_s'
+
+        r.save!
+
+        r_again = ::Spectable.find(r.id)
+
+        expect(r_again.perfect_b_oid).to be_an_objectid_object_matching(@perfect_b_oid)
+        expect(r_again.longer_b_oid).to be_an_objectid_object_matching(@longer_b_oid)
+
+        expect(r_again.too_short_b.strip).to eq('short_b_2')
+        expect(r_again.perfect_b.strip).to eq('perfect_b_2')
+        expect(r_again.longer_b.strip).to eq('longer_b_2')
+
+        r_again.perfect_s_oid.should be_an_objectid_object_matching(@perfect_s_oid)
+        r_again.longer_s_oid.should be_an_objectid_object_matching(@longer_s_oid)
+
+        expect(r_again.too_short_s).to eq('short_s_1')
+        expect(r_again.perfect_s).to eq('perfect_s_2')
+        expect(r_again.longer_s).to eq('longer_s')
+      end
+    end
+  end
+end