identity_cache 0.4.1 → 1.1.0

data/test/helpers/active_record_objects.rb

@@ -1,106 +0,0 @@
-module SwitchNamespace
-
-  module ClassMethods
-    def rails_cache_key_namespace
-      "#{self.namespace}:#{super}"
-    end
-  end
-
-  def self.included(base)
-    base.extend ClassMethods
-    base.class_eval do
-      class_attribute :namespace
-      self.namespace = 'ns'
-    end
-  end
-end
-
-module ActiveRecordObjects
-
-  def setup_models(base = ActiveRecord::Base)
-    Object.send :const_set, 'DeeplyAssociatedRecord', Class.new(base) {
-      include IdentityCache
-      belongs_to :item
-      belongs_to :associated_record
-      default_scope { order('name DESC') }
-    }
-
-    Object.send :const_set, 'AssociatedRecord', Class.new(base) {
-      include IdentityCache
-      belongs_to :item, inverse_of: :associated_records
-      belongs_to :item_two, inverse_of: :associated_records
-      has_many :deeply_associated_records
-      default_scope { order('id DESC') }
-    }
-
-    Object.send :const_set, 'NormalizedAssociatedRecord', Class.new(base) {
-      include IdentityCache
-      belongs_to :item
-      default_scope { order('id DESC') }
-    }
-
-    Object.send :const_set, 'NotCachedRecord', Class.new(base) {
-      belongs_to :item, :touch => true
-      default_scope { order('id DESC') }
-    }
-
-    Object.send :const_set, 'PolymorphicRecord', Class.new(base) {
-      belongs_to :owner, :polymorphic => true
-    }
-
-    Object.send :const_set, 'Deeply', Module.new
-    Deeply.send :const_set, 'Nested', Module.new
-    Deeply::Nested.send :const_set, 'AssociatedRecord', Class.new(base) {
-      include IdentityCache
-    }
-
-    Object.send :const_set, 'Item', Class.new(base) {
-      include IdentityCache
-      belongs_to :item
-      has_many :associated_records, inverse_of: :item
-      has_many :deeply_associated_records, inverse_of: :item
-      has_many :normalized_associated_records
-      has_many :not_cached_records
-      has_many :polymorphic_records, :as => 'owner'
-      has_one :polymorphic_record, :as => 'owner'
-      has_one :associated, :class_name => 'AssociatedRecord'
-    }
-
-    Object.send :const_set, 'ItemTwo', Class.new(base) {
-      include IdentityCache
-      has_many :associated_records, inverse_of: :item_two, foreign_key: :item_two_id
-      self.table_name = 'items2'
-    }
-
-    Object.send :const_set, 'KeyedRecord', Class.new(base) {
-      include IdentityCache
-      self.primary_key = "hashed_key"
-    }
-
-    Object.send :const_set, 'StiRecord', Class.new(base) {
-      include IdentityCache
-      has_many :polymorphic_records, :as => 'owner'
-    }
-
-    Object.send :const_set, 'StiRecordTypeA', Class.new(StiRecord) {
-    }
-  end
-
-  def teardown_models
-    ActiveSupport::DescendantsTracker.clear
-    ActiveSupport::Dependencies.clear
-    Object.send :remove_const, 'DeeplyAssociatedRecord'
-    Object.send :remove_const, 'PolymorphicRecord'
-    Object.send :remove_const, 'NormalizedAssociatedRecord'
-    Object.send :remove_const, 'AssociatedRecord'
-    Object.send :remove_const, 'NotCachedRecord'
-    Object.send :remove_const, 'Item'
-    Object.send :remove_const, 'ItemTwo'
-    Object.send :remove_const, 'KeyedRecord'
-    Object.send :remove_const, 'StiRecord'
-    Object.send :remove_const, 'StiRecordTypeA'
-    Deeply::Nested.send :remove_const, 'AssociatedRecord'
-    Deeply.send :remove_const, 'Nested'
-    Object.send :remove_const, 'Deeply'
-  end
-end

data/test/helpers/database_connection.rb

@@ -1,72 +0,0 @@
-module DatabaseConnection
-  def self.db_name
-    ENV.fetch('DB', 'mysql2')
-  end
-
-  def self.setup
-    db_config = ENV['DATABASE_URL'] || DEFAULT_CONFIG[db_name]
-    begin
-      ActiveRecord::Base.establish_connection(db_config)
-      ActiveRecord::Base.connection
-    rescue
-      raise unless db_config.is_a?(Hash)
-      ActiveRecord::Base.establish_connection(db_config.merge('database' => nil))
-      ActiveRecord::Base.connection.create_database(db_config['database'])
-      ActiveRecord::Base.establish_connection(db_config)
-    end
-  end
-
-  def self.drop_tables
-    TABLES.keys.each do |table|
-      ActiveRecord::Base.connection.drop_table(table) if table_exists?(table)
-    end
-  end
-
-  def self.table_exists?(table)
-    if ActiveRecord::Base.connection.respond_to?(:data_source_exists?)
-      ActiveRecord::Base.connection.data_source_exists?(table)
-    else
-      ActiveRecord::Base.connection.table_exists?(table)
-    end
-  end
-
-  def self.create_tables
-    TABLES.each do |table, fields|
-      fields = fields.dup
-      options = fields.last.is_a?(Hash) ? fields.pop : {}
-      ActiveRecord::Base.connection.create_table(table, options) do |t|
-        fields.each do |column_type, *args|
-          t.send(column_type, *args)
-        end
-      end
-    end
-  end
-
-  TABLES = {
-    :polymorphic_records           => [[:string, :owner_type], [:integer, :owner_id], [:timestamps, null: true]],
-    :deeply_associated_records     => [[:string, :name], [:integer, :associated_record_id], [:integer, :item_id], [:timestamps, null: true]],
-    :associated_records            => [[:string, :name], [:integer, :item_id], [:integer, :item_two_id]],
-    :normalized_associated_records => [[:string, :name], [:integer, :item_id], [:timestamps, null: true]],
-    :not_cached_records            => [[:string, :name], [:integer, :item_id], [:timestamps, null: true]],
-    :items                         => [[:integer, :item_id], [:string, :title], [:timestamps, null: true]],
-    :items2                        => [[:integer, :item_id], [:string, :title], [:timestamps, null: true]],
-    :keyed_records                 => [[:string, :value], :primary_key => "hashed_key"],
-    :sti_records                   => [[:string, :type], [:string, :name]],
-  }
-
-  DEFAULT_CONFIG = {
-    'mysql2' => {
-      'adapter'  => 'mysql2',
-      'database' => 'identity_cache_test',
-      'host'     => ENV['MYSQL_HOST'] || '127.0.0.1',
-      'username' => 'root'
-    },
-    'postgresql' => {
-      'adapter'  => 'postgresql',
-      'database' => 'identity_cache_test',
-      'host'     => ENV['POSTGRES_HOST'] || '127.0.0.1',
-      'username' => 'postgres',
-      'prepared_statements' => false,
-    }
-  }
-end

data/test/helpers/serialization_format.rb

@@ -1,42 +0,0 @@
-module SerializationFormat
-  def serialized_record
-    AssociatedRecord.cache_has_many :deeply_associated_records, :embed => true
-    AssociatedRecord.cache_belongs_to :item, :embed => false
-    Item.cache_has_many :associated_records, :embed => true
-    Item.cache_has_one :associated
-    time = Time.parse('1970-01-01T00:00:00 UTC')
-
-    record = Item.new(:title => 'foo')
-    record.associated_records << AssociatedRecord.new(:name => 'bar')
-    record.associated_records << AssociatedRecord.new(:name => 'baz')
-    record.associated = AssociatedRecord.new(:name => 'bork')
-    record.not_cached_records << NotCachedRecord.new(:name => 'NoCache', created_at: time)
-    record.associated.deeply_associated_records << DeeplyAssociatedRecord.new(:name => "corge", created_at: time)
-    record.associated.deeply_associated_records << DeeplyAssociatedRecord.new(:name => "qux", created_at: time)
-    record.created_at = time
-    record.save
-    [Item, NotCachedRecord, DeeplyAssociatedRecord].each do |model|
-      model.update_all(updated_at: time)
-    end
-    record.reload
-    Item.fetch(record.id)
-    IdentityCache.fetch(record.primary_cache_index_key)
-  end
-
-  def serialized_record_file
-    File.expand_path("../../fixtures/serialized_record.#{DatabaseConnection.db_name}", __FILE__)
-  end
-
-  def serialize(record, anIO = nil)
-    hash = {
-      :version => IdentityCache::CACHE_VERSION,
-      :record => record
-    }
-
-    if anIO
-      Marshal.dump(hash, anIO)
-    else
-      Marshal.dump(hash)
-    end
-  end
-end

data/test/helpers/update_serialization_format.rb

@@ -1,24 +0,0 @@
-$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
-
-require 'logger'
-require 'active_record'
-require 'memcached_store'
-require 'active_support/cache/memcached_store'
-require_relative 'serialization_format'
-require_relative 'database_connection'
-require_relative 'active_record_objects'
-require 'identity_cache'
-
-include SerializationFormat
-include ActiveRecordObjects
-
-DatabaseConnection.setup
-DatabaseConnection.drop_tables
-DatabaseConnection.create_tables
-IdentityCache.logger = Logger.new(nil)
-IdentityCache.cache_backend = ActiveSupport::Cache::MemcachedStore.new("localhost:11211", :support_cas => true)
-setup_models
-File.open(serialized_record_file, 'w') {|file| serialize(serialized_record, file) }
-puts "Serialized record to #{serialized_record_file}"
-IdentityCache.cache.clear
-teardown_models

data/test/identity_cache_test.rb

@@ -1,29 +0,0 @@
-require "test_helper"
-
-class IdentityCacheTest < IdentityCache::TestCase
-
-  class BadModelBase < ActiveRecord::Base
-    include IdentityCache
-  end
-
-  class BadModel < BadModelBase
-  end
-
-  def test_identity_cache_raises_if_loaded_twice
-    assert_raises(IdentityCache::AlreadyIncludedError) do
-      BadModel.class_eval do
-        include IdentityCache
-      end
-    end
-  end
-
-  def test_should_use_cache_outside_transaction
-    assert_equal true, IdentityCache.should_use_cache?
-  end
-
-  def test_should_use_cache_in_transaction
-    ActiveRecord::Base.transaction do
-      assert_equal false, IdentityCache.should_use_cache?
-    end
-  end
-end

data/test/index_cache_test.rb

@@ -1,161 +0,0 @@
-require "test_helper"
-
-class IndexCacheTest < IdentityCache::TestCase
-  NAMESPACE = IdentityCache::CacheKeyGeneration::DEFAULT_NAMESPACE
-
-  def setup
-    super
-    @record = Item.new
-    @record.id = 1
-    @record.title = 'bob'
-  end
-
-  def test_fetch_with_garbage_input
-    Item.cache_index :title, :id
-
-    assert_queries(1) do
-      assert_equal [], Item.fetch_by_title_and_id('garbage', 'garbage')
-    end
-  end
-
-  def test_fetch_with_unique_adds_limit_clause
-    Item.cache_index :title, :id, :unique => true
-
-    Item.connection.expects(:exec_query)
-      .with(regexp_matches(/ LIMIT 1\Z/i), any_parameters)
-      .returns(ActiveRecord::Result.new([], []))
-
-    assert_nil Item.fetch_by_title_and_id('title', '2')
-  end
-
-  def test_unique_index_caches_nil
-    Item.cache_index :title, :unique => true
-    assert_nil Item.fetch_by_title('bob')
-    assert_equal IdentityCache::CACHED_NIL, backend.read(cache_key(unique: true))
-  end
-
-  def test_unique_index_expired_by_new_record
-    Item.cache_index :title, :unique => true
-    IdentityCache.cache.write(cache_key(unique: true), IdentityCache::CACHED_NIL)
-    @record.save!
-    assert_equal IdentityCache::DELETED, backend.read(cache_key(unique: true))
-  end
-
-  def test_unique_index_filled_on_fetch_by
-    Item.cache_index :title, :unique => true
-    @record.save!
-    assert_equal @record, Item.fetch_by_title('bob')
-    assert_equal @record.id, backend.read(cache_key(unique: true))
-  end
-
-  def test_unique_index_expired_by_updated_record
-    Item.cache_index :title, :unique => true
-    @record.save!
-    old_cache_key = cache_key(unique: true)
-    IdentityCache.cache.write(old_cache_key, @record.id)
-
-    @record.title = 'robert'
-    new_cache_key = cache_key(unique: true)
-    IdentityCache.cache.write(new_cache_key, IdentityCache::CACHED_NIL)
-    @record.save!
-    assert_equal IdentityCache::DELETED, backend.read(old_cache_key)
-    assert_equal IdentityCache::DELETED, backend.read(new_cache_key)
-  end
-
-  def test_non_unique_index_caches_empty_result
-    Item.cache_index :title
-    assert_equal [], Item.fetch_by_title('bob')
-    assert_equal [], backend.read(cache_key)
-  end
-
-  def test_non_unique_index_expired_by_new_record
-    Item.cache_index :title
-    IdentityCache.cache.write(cache_key, [])
-    @record.save!
-    assert_equal IdentityCache::DELETED, backend.read(cache_key)
-  end
-
-  def test_non_unique_index_filled_on_fetch_by
-    Item.cache_index :title
-    @record.save!
-    assert_equal [@record], Item.fetch_by_title('bob')
-    assert_equal [@record.id], backend.read(cache_key)
-  end
-
-  def test_non_unique_index_fetches_multiple_records
-    Item.cache_index :title
-    @record.save!
-    record2 = Item.create(:title => 'bob') { |item| item.id = 2 }
-
-    assert_equal [@record, record2], Item.fetch_by_title('bob')
-    assert_equal [1, 2], backend.read(cache_key)
-  end
-
-  def test_non_unique_index_expired_by_updating_record
-    Item.cache_index :title
-    @record.save!
-    old_cache_key = cache_key
-    IdentityCache.cache.write(old_cache_key, [@record.id])
-
-    @record.title = 'robert'
-    new_cache_key = cache_key
-    IdentityCache.cache.write(new_cache_key, [])
-    @record.save!
-    assert_equal IdentityCache::DELETED, backend.read(old_cache_key)
-    assert_equal IdentityCache::DELETED, backend.read(new_cache_key)
-  end
-
-  def test_non_unique_index_expired_by_destroying_record
-    Item.cache_index :title
-    @record.save!
-    IdentityCache.cache.write(cache_key, [@record.id])
-    @record.destroy
-    assert_equal IdentityCache::DELETED, backend.read(cache_key)
-  end
-
-  def test_set_table_name_cache_fetch
-    Item.cache_index :title
-    Item.table_name = 'items2'
-    @record.save!
-    assert_equal [@record], Item.fetch_by_title('bob')
-    assert_equal [@record.id], backend.read(cache_key)
-  end
-
-  def test_fetch_by_index_raises_when_called_on_a_scope
-    Item.cache_index :title
-    assert_raises(IdentityCache::UnsupportedScopeError) do
-      Item.where(updated_at: nil).fetch_by_title('bob')
-    end
-  end
-
-  def test_fetch_by_unique_index_raises_when_called_on_a_scope
-    Item.cache_index :title, :id, :unique => true
-    assert_raises(IdentityCache::UnsupportedScopeError) do
-      Item.where(updated_at: nil).fetch_by_title_and_id('bob', 2)
-    end
-  end
-
-  def test_cache_index_on_derived_model_raises
-    assert_raises(IdentityCache::DerivedModelError) do
-      StiRecordTypeA.cache_index :name, :id
-    end
-  end
-
-  def test_cache_index_with_non_id_primary_key
-    KeyedRecord.cache_index :value
-    KeyedRecord.create!(value: "a") { |r| r.hashed_key = 123 }
-    assert_equal [123], KeyedRecord.fetch_by_value('a').map(&:id)
-  end
-
-  def test_unique_cache_index_with_non_id_primary_key
-    KeyedRecord.cache_index :value, unique: true
-    KeyedRecord.create!(value: "a") { |r| r.hashed_key = 123 }
-    assert_equal 123, KeyedRecord.fetch_by_value('a').id
-  end
-
-  private
-
-  def cache_key(unique: false)
-    "#{NAMESPACE}attr#{unique ? '' : 's'}:Item:id:title:#{cache_hash(@record.title)}"
-  end
-end

data/test/memoized_attributes_test.rb

@@ -1,49 +0,0 @@
-require "test_helper"
-
-class MemoizedAttributesTest < IdentityCache::TestCase
-  def test_memoization_should_not_break_dirty_tracking_with_empty_cache
-    item = Item.create!
-
-    IdentityCache.cache.with_memoization do
-      Item.fetch(item.id).title = "my title"
-      Item.fetch(item.id).update!(title: "my title")
-    end
-
-    assert_equal "my title", Item.find(item.id).title
-  end
-
-  def test_memoization_should_not_break_dirty_tracking_with_filled_cache
-    item = Item.create!
-
-    IdentityCache.cache.with_memoization do
-      Item.fetch(item.id)
-      Item.fetch(item.id).title = "my title"
-      Item.fetch(item.id).update!(title: "my title")
-    end
-
-    assert_equal "my title", Item.find(item.id).title
-  end
-
-  def test_memoization_with_fetch_multi_should_not_break_dirty_tracking_with_empty_cache
-    item = Item.create!
-
-    IdentityCache.cache.with_memoization do
-      Item.fetch_multi(item.id).first.title = "my title"
-      Item.fetch_multi(item.id).first.update!(title: "my title")
-    end
-
-    assert_equal "my title", Item.find(item.id).title
-  end
-
-  def test_memoization_with_fetch_multi_should_not_break_dirty_tracking_with_filled_cache
-    item = Item.create!
-
-    IdentityCache.cache.with_memoization do
-      Item.fetch_multi(item.id)
-      Item.fetch_multi(item.id).first.title = "my title"
-      Item.fetch_multi(item.id).first.update!(title: "my title")
-    end
-
-    assert_equal "my title", Item.find(item.id).title
-  end
-end