activeid 0.6.1

data/lib/active_id/version.rb

@@ -0,0 +1,3 @@
+module ActiveID
+  VERSION = "0.6.1".freeze
+end

data/spec/integration/examples_for_uuid_models.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+
+RSpec.shared_examples "model with UUIDs" do
+  let!(:article) { Fabricate model.name.underscore }
+  let!(:id) { article.id }
+  subject { model }
+
+  context "model" do
+    its(:primary_key) { is_expected.to eq("id") }
+    its(:all) { is_expected.to eq([article]) }
+    its(:first) { is_expected.to eq(article) }
+  end
+
+  context "existance" do
+    subject { article }
+    its(:id) { is_expected.to be_a UUIDTools::UUID }
+  end
+
+  context "interpolation" do
+    specify { model.where("id = :id", id: quoted_article_id) }
+  end
+
+  context "batch interpolation" do
+    before { model.update_all(["title = CASE WHEN id = :id THEN 'Passed' ELSE 'Nothing' END", id: quoted_article_id]) }
+    specify { expect(article.reload.title).to eq("Passed") }
+  end
+
+  context ".find" do
+    specify { expect(model.find(article.id)).to eq(article) }
+    specify { expect(model.find(id)).to eq(article) }
+    specify { expect(model.find(id.to_s)).to eq(article) }
+    specify { expect(model.find(id.raw)).to eq(article) }
+  end
+
+  context ".where" do
+    specify { expect(model.where(id: article).first).to eq(article) }
+    specify { expect(model.where(id: id).first).to eq(article) }
+    specify { expect(model.where(id: id.to_s).first).to eq(article) }
+    specify { expect(model.where(id: id.raw).first).to eq(article) }
+  end
+
+  context "#destroy" do
+    subject { article }
+    its(:delete) { is_expected.to be_truthy }
+    its(:destroy) { is_expected.to be_truthy }
+  end
+
+  context "#reload" do
+    subject { article }
+    its(:'reload.id') { is_expected.to eq(id) }
+    specify { expect(subject.reload(select: :another_uuid).id).to eq(id) }
+  end
+
+  shared_examples "for UUID attribute" do
+    let(:attr_type) { model.attribute_types[attr_name.to_s] }
+    let(:attr_getter) { article.method(attr_name) }
+    let(:attr_setter) { article.method("#{attr_name}=") }
+
+    let(:uuid) { UUIDTools::UUID.random_create }
+
+    it "has proper ActiveRecord type" do
+      expect(attr_type).to be_kind_of(ActiveID::Type::Base)
+    end
+
+    it "allows to assign UUID instance" do
+      attr_setter.(uuid)
+      expect(attr_getter.()).to be_an(UUIDTools::UUID) & eq(uuid)
+    end
+
+    it "allows to assign UUID string" do
+      attr_setter.(uuid.to_s)
+      expect(attr_getter.()).to be_an(UUIDTools::UUID) & eq(uuid)
+    end
+
+    it "persists UUID in database" do
+      attr_setter.(uuid)
+      article.save
+      article.reload
+      expect(attr_getter.()).to be_an(UUIDTools::UUID) & eq(uuid)
+    end
+  end
+
+  describe "UUID attribute which is a model's primary key" do
+    let(:attr_name) { :id }
+    include_examples "for UUID attribute"
+  end
+
+  describe "UUID attribute which isn't a model's primary key" do
+    let(:attr_name) { :another_uuid }
+    include_examples "for UUID attribute"
+  end
+end

data/spec/integration/examples_for_uuid_models_having_namespaces.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+RSpec.shared_examples "model with UUIDs and a namespace" do
+  let!(:article) { Fabricate model.name.underscore }
+  let!(:id) { article.id }
+  let!(:namespace) { model._uuid_namespace }
+  let!(:uuid) { UUIDTools::UUID.sha1_create(namespace, article.title) }
+  subject { article }
+  context "natural_key_with_namespace" do
+    its(:id) { is_expected.to eq(uuid) }
+  end
+end

data/spec/integration/examples_for_uuid_models_having_natural_keys.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+RSpec.shared_examples "model with UUIDs and a natural key" do
+  let!(:article) { Fabricate model.name.underscore }
+  let!(:id) { article.id }
+  let!(:uuid) { UUIDTools::UUID.sha1_create(UUIDTools::UUID_OID_NAMESPACE, article.title) }
+  subject { article }
+  context "natural_key" do
+    its(:id) { is_expected.to eq(uuid) }
+  end
+end

data/spec/integration/migrations_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+
+RSpec.describe "migration methods" do
+  before do
+    if ENV.fetch("NO_PATCHES", false)
+      skip "Migrations are unavailable without monkey patching"
+    end
+  end
+
+  shared_examples "active record examples" do |can_change_column_to_uuid: true|
+    let(:connection) { ActiveRecord::Base.connection }
+    let(:table_name) { :test_uuid_field_creation }
+    let(:table_columns) { connection.columns(table_name) }
+    let(:column) { table_columns.detect { |c| c.name.to_sym == column_name } }
+
+    def table_exists?(table_name)
+      connection.respond_to?(:data_source_exists?) ?
+        connection.data_source_exists?(table_name) :
+        connection.table_exists?(table_name)
+    end
+
+    around do |example|
+      connection.drop_table(table_name) if table_exists?(table_name)
+      connection.create_table(table_name)
+      expect(table_exists?(table_name)).to be(true)
+      example.run
+      connection.drop_table(table_name)
+    end
+
+    describe "#add_column" do
+      let(:column_name) { :uuid_column }
+
+      def perform
+        connection.add_column(table_name, column_name, :uuid)
+      end
+
+      it "adds a column of correct SQL type to the table" do
+        perform
+        expect(connection.column_exists?(table_name, column_name)).to be(true)
+        expect(column.sql_type).to eq(sql_type_for_uuid)
+      end
+    end
+
+    describe "#change_column" do
+      let(:column_name) { :string_col }
+
+      before do
+        connection.add_column(table_name, column_name, :string)
+      end
+
+      def perform
+        connection.change_column(table_name, column_name, :uuid)
+      end
+
+      if can_change_column_to_uuid
+        it "changes column type to a proper one for UUID storage" do
+          perform
+          expect(column.sql_type).to eq(sql_type_for_uuid)
+        end
+      else
+        it "raises exception when attempting to change the column type " +
+          "to one proper for UUID storage" do
+          expect { perform }.to raise_exception(ActiveRecord::StatementInvalid)
+        end
+      end
+    end
+  end
+
+  context "with SQLite3 backend" do
+    before { skip "backend unavailable" unless ENV["DB"] == "sqlite3" }
+
+    let(:sql_type_for_uuid) { "binary(16)" }
+
+    include_examples "active record examples"
+  end
+
+  context "with MySQL backend" do
+    before { skip "backend unavailable" unless ENV["DB"] == "mysql" }
+
+    let(:sql_type_for_uuid) { "binary(16)" }
+
+    include_examples "active record examples"
+  end
+
+  context "with PostgreSQL backend" do
+    before { skip "backend unavailable" unless ENV["DB"] == "postgresql" }
+
+    let(:sql_type_for_uuid) { "uuid" }
+
+    include_examples "active record examples", can_change_column_to_uuid: false
+  end
+end

data/spec/integration/model_without_uuids_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+RSpec.describe Article do
+  let!(:article) { Fabricate :article }
+  let(:id) { article.id }
+  let(:model) { Article }
+  subject { model }
+
+  context "model" do
+    its(:all) { is_expected.to eq([article]) }
+    its(:first) { is_expected.to eq(article) }
+  end
+
+  context "existance" do
+    subject { article }
+    its(:id) { is_expected.to be_a Integer }
+  end
+
+  context ".find" do
+    specify { expect(model.find(id)).to eq(article) }
+  end
+
+  context ".where" do
+    specify { expect(model.where(id: id).first).to eq(article) }
+  end
+
+  context "#destroy" do
+    subject { article }
+    its(:delete) { is_expected.to be_truthy }
+    its(:destroy) { is_expected.to be_truthy }
+  end
+
+  context "#save" do
+    subject { article }
+    let(:array) { [1, 2, 3] }
+
+    its(:save) { is_expected.to be_truthy }
+
+    context "when change array field" do
+      before { article.some_array = array }
+      its(:save) { is_expected.to be_truthy }
+    end
+  end
+end

data/spec/integration/no_patches_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+RSpec.describe "without monkey patches" do
+  before do
+    unless ENV.fetch("NO_PATCHES", false)
+      skip "Monkey patching is enabled in this build"
+    end
+  end
+
+  it "does not patch ActiveRecord connection" do
+    db_conn = ActiveRecord::Base.connection
+    db_conn_modules = db_conn.singleton_class.ancestors
+
+    expect(db_conn_modules).to all(satisfy { |m| /ActiveID/ !~ m.name })
+  end
+
+  it "does not patch Table class" do
+    table_modules = ActiveRecord::ConnectionAdapters::Table.ancestors
+    expect(table_modules).to all(satisfy { |m| /ActiveID/ !~ m.name })
+  end
+
+  it "does not patch TableDefinition class" do
+    table_modules = ActiveRecord::ConnectionAdapters::TableDefinition.ancestors
+    expect(table_modules).to all(satisfy { |m| /ActiveID/ !~ m.name })
+  end
+end

data/spec/integration/storing_uuids_as_binaries_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+Dir["#{__dir__}/examples_*.rb"].each { |f| require f }
+
+RSpec.describe "storing simple UUIDs as binaries" do
+  if ENV["DB"] == "postgresql"
+    before { skip "Binary UUID storage does not work in PostgreSQL" }
+  end
+
+  include_examples "model with UUIDs" do
+    let(:model) { BinaryUuidArticle }
+    let(:quoted_article_id) { ActiveID.quote_as_binary(article.id) }
+  end
+end
+
+RSpec.describe "storing UUIDs with a natural key as binaries" do
+  if ENV["DB"] == "postgresql"
+    before { skip "Binary UUID storage does not work in PostgreSQL" }
+  end
+
+  include_examples "model with UUIDs and a natural key" do
+    let(:model) { BinaryUuidArticleWithNaturalKey }
+  end
+end
+
+RSpec.describe "storing UUIDs with a namespace as binaries" do
+  if ENV["DB"] == "postgresql"
+    before { skip "Binary UUID storage does not work in PostgreSQL" }
+  end
+
+  include_examples "model with UUIDs and a namespace" do
+    let(:model) { BinaryUuidArticleWithNamespace }
+  end
+end

data/spec/integration/storing_uuids_as_strings_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+Dir["#{__dir__}/examples_*.rb"].each { |f| require f }
+
+RSpec.describe "storing simple UUIDs as strings" do
+  include_examples "model with UUIDs" do
+    let(:model) { StringUuidArticle }
+    let(:quoted_article_id) { article.id.to_s }
+  end
+end
+
+RSpec.describe "storing UUIDs with a natural key as strings" do
+  include_examples "model with UUIDs and a natural key" do
+    let(:model) { StringUuidArticleWithNaturalKey }
+  end
+end
+
+RSpec.describe "storing UUIDs with a namespace as strings" do
+  include_examples "model with UUIDs and a namespace" do
+    let(:model) { StringUuidArticleWithNamespace }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,64 @@
+require "simplecov"
+SimpleCov.start
+
+if ENV.key?("CI")
+  require "codecov"
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+
+ENV["DB"] ||= "sqlite3"
+
+require "bundler/setup"
+Bundler.require :development
+
+if ENV.fetch("NO_PATCHES", false)
+  require "active_id"
+else
+  require "active_id/all"
+end
+
+Dir[File.expand_path("support/**/*.rb", __dir__)].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

data/spec/support/0_logger.rb

@@ -0,0 +1,2 @@
+log_path = File.expand_path("../../log/test.log", __dir__)
+ActiveRecord::Base.logger = Logger.new(log_path)

data/spec/support/1_db_connection.rb

@@ -0,0 +1,3 @@
+db_config_path = File.expand_path("database.yml", __dir__)
+ActiveRecord::Base.configurations = YAML::safe_load(File.read(db_config_path))
+ActiveRecord::Base.establish_connection(ENV["DB"].to_sym)

data/spec/support/2_db_cleaner.rb

@@ -0,0 +1,14 @@
+RSpec.configure do |config|
+  config.before(:suite) do
+    DatabaseCleaner.clean_with(:truncation)
+    DatabaseCleaner.strategy = :transaction
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end

data/spec/support/database.yml

@@ -0,0 +1,12 @@
+sqlite3:
+  adapter: sqlite3
+  database: ":memory:"
+postgresql:
+  adapter: postgresql
+  host: localhost
+  database: activeid_test
+mysql:
+  adapter: mysql2
+  username: root
+  database: activeid_test
+  encoding: utf8