identity_cache 0.5.1 → 1.0.0

data/test/fetch_test.rb

@@ -1,258 +0,0 @@
-require "test_helper"
-
-class FetchTest < IdentityCache::TestCase
-  NAMESPACE = IdentityCache::CacheKeyGeneration::DEFAULT_NAMESPACE
-
-  def setup
-    super
-    Item.cache_index :title, :unique => true
-    Item.cache_index :id, :title, :unique => true
-
-    @record = Item.new
-    @record.id = 1
-    @record.title = 'bob'
-    @cached_value = { class: @record.class.name, attributes: @record.attributes_before_type_cast }
-    @blob_key = "#{NAMESPACE}blob:Item:#{cache_hash("created_at:datetime,id:integer,item_id:integer,title:string,updated_at:datetime")}:1"
-    @index_key = "#{NAMESPACE}attr:Item:id:title:#{cache_hash('bob')}"
-  end
-
-  def test_fetch_with_garbage_input
-    assert_nil Item.fetch_by_id('garbage')
-  end
-
-  def test_fetch_cache_hit
-    IdentityCache.cache.expects(:fetch).with(@blob_key).returns(@cached_value)
-
-    assert_equal @record, Item.fetch(1)
-  end
-
-  def test_fetch_hit_cache_namespace
-    old_ns = IdentityCache.cache_namespace
-    IdentityCache.cache_namespace = proc { |model| "#{model.table_name}:#{old_ns}" }
-
-    new_blob_key = "items:#{@blob_key}"
-    IdentityCache.cache.expects(:fetch).with(new_blob_key).returns(@cached_value)
-
-    assert_equal @record, Item.fetch(1)
-  ensure
-    IdentityCache.cache_namespace = old_ns
-  end
-
-  def test_exists_with_identity_cache_when_cache_hit
-    IdentityCache.cache.expects(:fetch).with(@blob_key).returns(@cached_value)
-
-    assert Item.exists_with_identity_cache?(1)
-  end
-
-  def test_exists_with_identity_cache_when_cache_miss_and_in_db
-    fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
-    Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
-
-    assert Item.exists_with_identity_cache?(1)
-    assert fetch.has_been_called_with?(@blob_key)
-  end
-
-  def test_exists_with_identity_cache_when_cache_miss_and_not_in_db
-    fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
-    Item.expects(:resolve_cache_miss).with(1).once.returns(nil)
-
-    assert !Item.exists_with_identity_cache?(1)
-    assert fetch.has_been_called_with?(@blob_key)
-  end
-
-  def test_fetch_miss
-    Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
-
-    results = []
-    fetch = Spy.on(IdentityCache.cache, :fetch).and_return {|_, &block| block.call.tap {|result| results << result}}
-
-    assert_equal @record, Item.fetch(1)
-    assert fetch.has_been_called_with?(@blob_key)
-    assert_equal [@cached_value], results
-  end
-
-  def test_fetch_miss_with_non_id_primary_key
-    hashed_key = Zlib::crc32("foo") % (2 ** 30 - 1)
-    fixture = KeyedRecord.create!(:value => "foo") { |r| r.hashed_key = hashed_key }
-    assert_equal fixture, KeyedRecord.fetch(hashed_key)
-  end
-
-  def test_fetch_conflict
-    resolve_cache_miss = Spy.on(Item, :resolve_cache_miss).and_return do
-      @record.send(:expire_cache)
-      @record
-    end
-    add = Spy.on(fetcher, :add).and_call_through
-
-    assert_equal @record, Item.fetch(1)
-    assert resolve_cache_miss.has_been_called_with?(1)
-    assert add.has_been_called_with?(@blob_key, @cached_value)
-    assert_equal IdentityCache::DELETED, backend.read(@record.primary_cache_index_key)
-  end
-
-  def test_fetch_conflict_after_delete
-    @record.send(:expire_cache)
-    assert_equal IdentityCache::DELETED, backend.read(@record.primary_cache_index_key)
-
-    resolve_cache_miss = Spy.on(Item, :resolve_cache_miss).and_return do
-      @record.send(:expire_cache)
-      @record
-    end
-    add = Spy.on(IdentityCache.cache.cache_fetcher, :add).and_call_through
-
-    assert_equal @record, Item.fetch(1)
-    assert resolve_cache_miss.has_been_called_with?(1)
-    refute add.has_been_called?
-    assert_equal IdentityCache::DELETED, backend.read(@record.primary_cache_index_key)
-  end
-
-  def test_fetch_by_id_not_found_should_return_nil
-    nonexistent_record_id = 10
-    fetcher.expects(:add).with(@blob_key + '0', IdentityCache::CACHED_NIL)
-
-    assert_nil Item.fetch_by_id(nonexistent_record_id)
-  end
-
-  def test_fetch_not_found_should_raise
-    nonexistent_record_id = 10
-    fetcher.expects(:add).with(@blob_key + '0', IdentityCache::CACHED_NIL)
-
-    assert_raises(ActiveRecord::RecordNotFound) { Item.fetch(nonexistent_record_id) }
-  end
-
-  def test_cached_nil_expiry_on_record_creation
-    key = @record.primary_cache_index_key
-
-    assert_nil Item.fetch_by_id(@record.id)
-    assert_equal IdentityCache::CACHED_NIL, backend.read(key)
-
-    @record.save!
-    assert_equal IdentityCache::DELETED, backend.read(key)
-  end
-
-  def test_fetch_by_title_hit
-    values = []
-    fetch = Spy.on(IdentityCache.cache, :fetch).and_return do |key, &block|
-      case key
-      # Read record with title bob
-      when @index_key then block.call.tap {|val| values << val}
-      # got id, do memcache lookup on that, hit -> done
-      when @blob_key then @cached_value
-      end
-    end
-
-    # Id not found, use sql, SELECT id FROM records WHERE title = '...' LIMIT 1"
-    Item.connection.expects(:exec_query).returns(ActiveRecord::Result.new(['id'], [[1]]))
-
-    assert_equal @record, Item.fetch_by_title('bob')
-    assert_equal [1], values
-    assert fetch.has_been_called_with?(@index_key)
-    assert fetch.has_been_called_with?(@blob_key)
-  end
-
-  def test_fetch_by_title_cache_namespace
-    Item.send(:include, SwitchNamespace)
-    IdentityCache.cache.expects(:fetch).with("ns:#{@index_key}").returns(1)
-    IdentityCache.cache.expects(:fetch).with("ns:#{@blob_key}").returns(@cached_value)
-
-    assert_equal @record, Item.fetch_by_title('bob')
-  end
-
-  def test_fetch_by_title_stores_idcnil
-    Item.connection.expects(:exec_query).once.returns(ActiveRecord::Result.new([], []))
-    add = Spy.on(fetcher, :add).and_call_through
-    fetch = Spy.on(fetcher, :fetch).and_call_through
-    assert_nil Item.fetch_by_title('bob') # exec_query => nil
-
-    assert_nil Item.fetch_by_title('bob') # returns cached nil
-    assert_nil Item.fetch_by_title('bob') # returns cached nil
-
-    assert add.has_been_called_with?(@index_key, IdentityCache::CACHED_NIL)
-    assert_equal 3, fetch.calls.length
-  end
-
-  def test_fetch_by_bang_method
-    Item.connection.expects(:exec_query).returns(ActiveRecord::Result.new([], []))
-    assert_raises ActiveRecord::RecordNotFound do
-      Item.fetch_by_title!('bob')
-    end
-  end
-
-  def test_fetch_does_not_communicate_to_cache_with_nil_id
-    fetcher.expects(:fetch).never
-    fetcher.expects(:add).never
-    assert_raises(ActiveRecord::RecordNotFound) { Item.fetch(nil) }
-  end
-
-  def test_fetch_cache_hit_does_not_checkout_database_connection
-    @record.save!
-    record = Item.fetch(@record.id)
-
-    ActiveRecord::Base.clear_active_connections!
-
-    assert_equal record, Item.fetch(@record.id)
-
-    assert_equal false, ActiveRecord::Base.connection_handler.active_connections?
-  end
-
-  def test_fetch_raises_when_called_on_a_scope
-    assert_raises(IdentityCache::UnsupportedScopeError) do
-      Item.where(updated_at: nil).fetch(1)
-    end
-  end
-
-  def test_fetch_by_raises_when_called_on_a_scope
-    assert_raises(IdentityCache::UnsupportedScopeError) do
-      Item.where(updated_at: nil).fetch_by_id(1)
-    end
-  end
-
-  def test_fetch_on_derived_model_raises
-    assert_raises(IdentityCache::DerivedModelError) do
-      StiRecordTypeA.fetch(1)
-    end
-  end
-
-  def test_returned_records_are_readonly_on_cache_hit
-    IdentityCache.with_fetch_read_only_records do
-      IdentityCache.cache.expects(:fetch).with(@blob_key).returns(@cached_value)
-      assert Item.fetch(1).readonly?
-    end
-  end
-
-  def test_returned_records_are_readonly_on_cache_miss
-    IdentityCache.with_fetch_read_only_records do
-      fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
-      Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
-
-      assert Item.exists_with_identity_cache?(1)
-      assert fetch.has_been_called_with?(@blob_key)
-      assert Item.fetch(1).readonly?
-    end
-  end
-
-  def test_returned_records_are_not_readonly_with_open_transactions
-    IdentityCache.with_fetch_read_only_records do
-
-      @record.transaction do
-        fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
-        Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
-
-        refute IdentityCache.should_use_cache?
-        refute fetch.has_been_called_with?(@blob_key)
-        refute Item.fetch(1).readonly?, "Fetched item was read-only"
-      end
-    end
-  end
-
-  def test_respects_should_use_cache_on_record
-    @record.save
-    Item.stubs(:should_use_cache?).returns(false)
-
-    assert_memcache_operations(0) do
-      assert_queries(1) do
-        Item.fetch_by_id(@record.id)
-      end
-    end
-  end
-end

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,51 +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) do
-      STDERR.puts(
-        "\e[31m" \
-          "The record could not be retrieved from the cache." \
-          "Did you configure MEMCACHED_HOST?" \
-          "\e[0m",
-      )
-      exit(1)
-    end
-  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