kasket 3.1.5 → 3.2.0

data/test/cache_expiry_test.rb

@@ -1,49 +0,0 @@
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class CacheExpiryTest < ActiveSupport::TestCase
-  fixtures :blogs, :posts
-
-  context "a cached object" do
-    setup do
-      post = Post.first
-      @post = Post.find(post.id)
-
-      assert(Kasket.cache.read(@post.kasket_key))
-    end
-
-    should "be removed from cache when deleted" do
-      @post.destroy
-      assert_nil(Kasket.cache.read(@post.kasket_key))
-    end
-
-    should "clear all indices for instance when deleted" do
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "id=#{@post.id}")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'/first")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "blog_id=#{@post.blog_id}/id=#{@post.id}")
-      Kasket.cache.expects(:delete).never
-
-      @post.destroy
-    end
-
-    should "be removed from cache when updated" do
-      @post.title = "new_title"
-      @post.save
-      assert_nil(Kasket.cache.read(@post.kasket_key))
-    end
-
-    should "clear all indices for instance when updated" do
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "id=#{@post.id}")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'/first")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='new_title'")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='new_title'/first")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "blog_id=#{@post.blog_id}/id=#{@post.id}")
-      Kasket.cache.expects(:delete).never
-
-      @post.title = "new_title"
-      @post.save
-    end
-
-  end
-end

data/test/cacheable_test.rb

@@ -1,58 +0,0 @@
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class CacheableTest < ActiveSupport::TestCase
-  context "#store_in_kasket" do
-    should "only cache object that are kasket_cacheable?" do
-      post = Post.send(:instantiate, { 'id' => 1, 'title' => 'Hello' })
-
-      post.expects(:kasket_cacheable?).returns(true)
-      Kasket.cache.expects(:write).once
-      post.store_in_kasket
-
-      post.expects(:kasket_cacheable?).returns(false)
-      Kasket.cache.expects(:write).never
-      post.store_in_kasket
-    end
-  end
-
-  context "caching of results of find" do
-    setup do
-      @post_database_result = { 'id' => 1, 'title' => 'Hello' }
-      @post_records = [Post.send(:instantiate, @post_database_result)]
-      Post.stubs(:find_by_sql_without_kasket).returns(@post_records)
-
-      @comment_database_result = [{ 'id' => 1, 'body' => 'Hello' }, { 'id' => 2, 'body' => 'World' }]
-      @comment_records = @comment_database_result.map {|r| Comment.send(:instantiate, r)}
-      Comment.stubs(:find_by_sql_without_kasket).returns(@comment_records)
-    end
-
-    context "with just one result" do
-      should "write result in cache if it is kasket_cacheable?" do
-        Post.any_instance.expects(:kasket_cacheable?).returns(true)
-        Kasket.cache.expects(:write).once
-        Post.find(1)
-      end
-
-      should "not write result in cache if it is not kasket_cacheable?" do
-        Post.any_instance.expects(:kasket_cacheable?).returns(false)
-        Kasket.cache.expects(:write).never
-        Post.find(1)
-      end
-    end
-
-    context "with several results" do
-      should "write result in cache if all results are kasket_cacheable?" do
-        Comment.any_instance.stubs(:kasket_cacheable?).returns(true)
-        Kasket.cache.expects(:write).times(@comment_records.size + 1)
-        Comment.all(:conditions => {:post_id => 1})
-      end
-
-      should "not write result in cache if any of them are not kasket_cacheable?" do
-        @comment_records[0].expects(:kasket_cacheable?).returns(true)
-        @comment_records[1].expects(:kasket_cacheable?).returns(false)
-        Kasket.cache.expects(:write).never
-        Comment.all(:conditions => {:post_id => 1})
-      end
-    end
-  end
-end

data/test/configuration_mixin_test.rb

@@ -1,44 +0,0 @@
-require File.expand_path("helper", File.dirname(__FILE__))
-require "digest/md5"
-
-class ConfigurationMixinTest < ActiveSupport::TestCase
-  context "Generating cache keys" do
-    should "not choke on empty numeric attributes" do
-      expected_cache_key = "#{Post.kasket_key_prefix}blog_id=null"
-      query_attributes   = [ [:blog_id, ''] ]
-
-      assert_equal expected_cache_key, Post.kasket_key_for(query_attributes)
-    end
-
-    should "not fail on unknown columns" do
-      expected_cache_key = "#{Post.kasket_key_prefix}does_not_exist=111"
-      query_attributes   = [ [:does_not_exist, '111'] ]
-
-      assert_equal expected_cache_key, Post.kasket_key_for(query_attributes)
-    end
-
-    should "not generate keys longer that 255" do
-      very_large_number = (1..999).to_a.join
-      query_attributes  = [ [:blog_id, very_large_number] ]
-
-      assert(Post.kasket_key_for(query_attributes).size < 255)
-    end
-
-    should "not generate keys with spaces" do
-      query_attributes = [ [:title, 'this key has speces'] ]
-
-      assert(!(Post.kasket_key_for(query_attributes) =~ /\s/))
-    end
-
-    should "downcase string attributes" do
-      query_attributes = [ [:title, 'ThIs'] ]
-      expected_cache_key = "#{Post.kasket_key_prefix}title='this'"
-
-      assert_equal expected_cache_key, Post.kasket_key_for(query_attributes)
-    end
-
-    should "build correct prefix" do
-      assert_equal "kasket-#{Kasket::Version::PROTOCOL}/R#{ActiveRecord::VERSION::MAJOR}#{ActiveRecord::VERSION::MINOR}/posts/version=#{POST_VERSION}/", Post.kasket_key_prefix
-    end
-  end
-end

data/test/database.yml

@@ -1,7 +0,0 @@
-test:
-  adapter: mysql
-  encoding: utf8
-  database: kasket_test
-  username: root
-  password:
-  host: 127.0.0.1

data/test/dirty_test.rb

@@ -1,16 +0,0 @@
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class DirtyTest < ActiveSupport::TestCase
-  fixtures :blogs, :posts
-
-  should "clear the indices when a dirty method is called" do
-    post = Post.first
-
-    Post.cache { pots = Post.find(post.id) }
-    assert(Kasket.cache.read(post.kasket_key))
-
-    post.make_dirty!
-
-    assert_nil(Kasket.cache.read(post.kasket_key))
-  end
-end

data/test/find_one_test.rb

@@ -1,61 +0,0 @@
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class FindOneTest < ActiveSupport::TestCase
-  fixtures :blogs, :posts
-
-  should "cache find(id) calls" do
-    post = Post.first
-    Kasket.cache.write(post.kasket_key, nil)
-    assert_equal(post, Post.find(post.id))
-    assert(Kasket.cache.read(post.kasket_key))
-    Post.connection.expects(:select_all).never
-    assert_equal(post, Post.find(post.id))
-  end
-
-  should "only cache on indexed attributes" do
-    Kasket.cache.expects(:read).twice
-    Post.find_by_id(1)
-    Post.find_by_id(1, :conditions => {:blog_id => 2})
-
-    Kasket.cache.expects(:read).never
-    Post.first :conditions => {:blog_id => 2}
-  end
-
-  should "not use cache when using the :select option" do
-    post = Post.first
-    assert_nil(Kasket.cache.read(post.kasket_key))
-
-    Post.find(post.id, :select => 'title')
-    assert_nil(Kasket.cache.read(post.kasket_key))
-
-    Post.find(post.id)
-    assert(Kasket.cache.read(post.kasket_key))
-
-    Kasket.cache.expects(:read)
-    Post.find(post.id, :select => nil)
-
-    Kasket.cache.expects(:read).never
-    Post.find(post.id, :select => 'title')
-  end
-
-  should "respect scope" do
-    post = Post.find(Post.first.id)
-    other_blog = Blog.first(:conditions => "id != #{post.blog_id}")
-
-    assert(Kasket.cache.read(post.kasket_key))
-
-    assert_raise(ActiveRecord::RecordNotFound) do
-      other_blog.posts.find(post.id)
-    end
-  end
-
-  should "use same scope when finding on has_many" do
-    post = Blog.first.posts.first
-    blog = Blog.first
-    Rails.cache.clear
-
-    post = blog.posts.find_by_id(post.id)
-    key  = post.kasket_key.sub(%r{(/id=#{post.id})}, "/blog_id=#{Blog.first.id}\\1")
-    assert(Kasket.cache.read(key))
-  end
-end

data/test/find_some_test.rb

@@ -1,55 +0,0 @@
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class FindSomeTest < ActiveSupport::TestCase
-  fixtures :blogs, :posts
-
-  def setup
-    @post1 = Post.first
-    @post2 = Post.last
-    Post.find(@post1.id, @post2.id)
-    assert Kasket.cache.read(@post1.kasket_key)
-    assert Kasket.cache.read(@post2.kasket_key)
-  end
-
-  should "use cache for find(id, id) calls" do
-    Post.connection.expects(:select_all).never
-    Post.find(@post1.id, @post2.id)
-  end
-
-  should "cache when found using find(id, id) calls" do
-    Kasket.cache.delete(@post1.kasket_key)
-    Kasket.cache.delete(@post2.kasket_key)
-
-    Post.find(@post1.id, @post2.id)
-
-    assert Kasket.cache.read(@post1.kasket_key)
-    assert Kasket.cache.read(@post2.kasket_key)
-  end
-
-  should "only lookup the records that are not in the cache" do
-    Kasket.cache.delete(@post2.kasket_key)
-
-    # has to lookup post2 via db
-    Post.expects(:find_by_sql_without_kasket).returns([@post2])
-    found_posts = Post.find(@post1.id, @post2.id)
-    assert_equal [@post1, @post2].map(&:id).sort, found_posts.map(&:id).sort
-
-    # now all are cached
-    Post.expects(:find_by_sql_without_kasket).never
-    found_posts = Post.find(@post1.id, @post2.id)
-    assert_equal [@post1, @post2].map(&:id).sort, found_posts.map(&:id).sort
-  end
-
-  context "unfound" do
-    should "ignore unfound when using find_all_by_id" do
-      found_posts = Post.find_all_by_id([@post1.id, 1231232])
-      assert_equal [@post1.id], found_posts.map(&:id)
-    end
-
-    should "not ignore unfound when using find" do
-      assert_raise ActiveRecord::RecordNotFound do
-        Post.find(@post1.id, 1231232)
-      end
-    end
-  end
-end

data/test/fixtures/authors.yml

@@ -1,7 +0,0 @@
-mick:
-  name: Mick Staugaard
-  metadata:
-    sex: male
-
-eric:
-  name: Eric Chapweske

data/test/fixtures/blogs.yml

@@ -1,5 +0,0 @@
-a_blog:
-  name: My Blog
-
-other_blog:
-  name: Some Other Blog

data/test/fixtures/comments.yml

@@ -1,16 +0,0 @@
-few_comments_1:
-  id: 1
-  post_id: 2
-  body: what ever body 1
-
-few_comments_2:
-  id: 2
-  post_id: 2
-  body: what ever body 2
-
-<% (1..10).each do |i| %>
-many_comments_<%= i %>:
-  post: has_many_comments
-  body: what ever body <%= i %>
-<% end %>
-

data/test/fixtures/posts.yml

@@ -1,24 +0,0 @@
-no_comments:
-  id: 1
-  blog: a_blog
-  title: no_comments
-  author: mick
-  created_at: 2013-10-14 15:30:00
-
-has_two_comments:
-  id: 2
-  blog: a_blog
-  title: few_comments
-  author: mick
-
-on_other_blog:
-  id: 3
-  blog: other_blog
-  title: no_comments
-  author: eric
-
-has_many_comments:
-  id: 4
-  blog: a_blog
-  title: many_comments
-  author: eric

data/test/helper.rb

@@ -1,84 +0,0 @@
-require 'rubygems'
-
-require 'bundler'
-Bundler.setup
-# shoulda-matchers dependency:
-require 'active_support/core_ext/module/delegation'
-Bundler.require(:default, :development)
-
-if defined?(Debugger)
-  ::Debugger.start
-  ::Debugger.settings[:autoeval] = true if ::Debugger.respond_to?(:settings)
-end
-
-require 'test/unit'
-require 'mocha'
-require 'active_record'
-require "logger"
-
-raise "Must configure #time_zone_aware_attributes prior to models" if defined?(Post)
-ENV['TZ'] = 'utc'
-ActiveRecord::Base.time_zone_aware_attributes = true
-ActiveRecord::Base.logger = Logger.new(StringIO.new)
-
-require 'active_record/fixtures'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'kasket'
-
-Kasket.setup
-
-class ActiveSupport::TestCase
-  include ActiveRecord::TestFixtures
-
-  def create_fixtures(*table_names)
-    if block_given?
-      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) { yield }
-    else
-      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names)
-    end
-  end
-
-  self.use_transactional_fixtures = true
-
-  self.use_instantiated_fixtures  = false
-
-  setup :clear_cache
-  def clear_cache
-    Kasket.cache.clear
-  end
-
-  def arel?
-    self.class.arel?
-  end
-
-  def self.arel?
-    ActiveRecord::VERSION::MAJOR >= 3 && ActiveRecord::VERSION::MINOR >= 1
-  end
-end
-
-ActiveSupport::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"
-$LOAD_PATH.unshift(ActiveSupport::TestCase.fixture_path)
-
-class ActiveSupport::TestCase
-  fixtures :all
-end
-
-module Rails
-  module_function
-  CACHE = ActiveSupport::Cache::MemoryStore.new
-  LOGGER = Logger.new(STDOUT)
-
-  def cache
-    CACHE
-  end
-
-  def logger
-    LOGGER
-  end
-end
-
-require 'test_models'
-POST_VERSION = Post.column_names.join.sum
-COMMENT_VERSION = Comment.column_names.join.sum

data/test/parser_test.rb

@@ -1,153 +0,0 @@
-require File.expand_path("helper", File.dirname(__FILE__))
-require 'kasket/query_parser'
-
-class ParserTest < ActiveSupport::TestCase
-  def parse(options)
-    scope = Post
-    if arel?
-      options.each do |k,v|
-        scope = case k
-        when :conditions then scope.where(v)
-        else
-          scope.send(k, v)
-        end
-      end
-      scope.to_kasket_query
-    elsif ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
-      @parser.parse(scope.scoped(options).to_sql)
-    else
-      sql = scope.send(:construct_finder_sql, options)
-      @parser.parse(sql)
-    end
-  end
-
-  context "Parsing" do
-    setup do
-      @parser = Kasket::QueryParser.new(Post)
-    end
-
-    should "not support conditions with number as column (e.g. 0 = 1)" do
-      assert !parse(:conditions => "0 = 1")
-    end
-
-    should "not support conditions with number as column and parans (e.g. 0 = 1)" do
-      assert !parse(:conditions => "(0 = 1)")
-    end
-
-    should "not support :order" do
-      assert !parse(:conditions => "id = 1", :order => "xxx")
-    end
-
-    should 'not support IN queries in combination with other conditions' do
-      assert !parse(:conditions => {:id => [1,2,3], :is_active => true})
-    end
-
-    should "extract conditions" do
-      kasket_query = parse(:conditions => {:title => 'red', :blog_id => 1})
-      assert_equal [[:blog_id, "1"], [:title, "red"]], kasket_query[:attributes]
-    end
-
-    should "extract conditions with parans that do not surround" do
-      kasket_query = parse(:conditions => "(title = 'red') AND (blog_id = 1)")
-      if ActiveRecord::VERSION::STRING > "3.1.0"
-        assert !kasket_query
-      else
-        assert_equal [[:blog_id, "1"], [:title, "red"]], kasket_query[:attributes]
-      end
-    end
-
-    should "extract required index" do
-      assert_equal [:blog_id, :title], parse(:conditions => {:title => 'red', :blog_id => 1})[:index]
-    end
-
-    should "only support queries against its model's table" do
-      assert !parse(:conditions => {'blogs.id' => 2}, :from => 'apples')
-    end
-
-    should "support cachable queries" do
-      assert parse(:conditions => {:id => 1})
-      assert parse(:conditions => {:id => 1}, :limit => 1)
-    end
-
-    should "support IN queries on id" do
-      assert_equal [[:id, ['1', '2', '3']]], parse(:conditions => {:id => [1,2,3]})[:attributes]
-    end
-
-    should "not support IN queries on other attributes" do
-      assert !parse(:conditions => {:hest => [1,2,3]})
-    end
-
-    should "support vaguely formatted queries" do
-      assert @parser.parse('SELECT * FROM "posts" WHERE (title = red AND blog_id = big)')
-    end
-
-    context "extract options" do
-      should "provide the limit" do
-        assert_equal nil, parse(:conditions => {:id => 2})[:limit]
-        assert_equal 1, parse(:conditions => {:id => 2}, :limit => 1)[:limit]
-      end
-    end
-
-    context "unsupported queries" do
-      should "include advanced limits" do
-        assert !parse(:conditions => {:title => 'red', :blog_id => 1}, :limit => 2)
-      end
-
-      should "include joins" do
-        assert !parse(:conditions => {:title => 'test', 'apple.tree_id' => 'posts.id'}, :from => ['posts', 'apple'])
-        assert !parse(:conditions => {:title => 'test'}, :joins => :comments)
-      end
-
-      should "include specific selects" do
-        assert !parse(:conditions => {:title => 'red'}, :select => :id)
-      end
-
-      should "include offset" do
-        assert !parse(:conditions => {:title => 'red'}, :limit => 1, :offset => 2)
-      end
-
-      should "include order" do
-        assert !parse(:conditions => {:title => 'red'}, :order => :title)
-      end
-
-      should "include the OR operator" do
-        assert !parse(:conditions => "title = 'red' OR blog_id = 1")
-      end
-    end
-
-    context "key generation" do
-      should "include the table name and version" do
-        kasket_query = parse(:conditions => {:id => 1})
-        assert_match(/^kasket-#{Kasket::Version::PROTOCOL}\/R#{ActiveRecord::VERSION::MAJOR}#{ActiveRecord::VERSION::MINOR}\/posts\/version=#{POST_VERSION}\//, kasket_query[:key])
-      end
-
-      should "include all indexed attributes" do
-        kasket_query = parse(:conditions => {:id => 1})
-        assert_match(/id=1$/, kasket_query[:key])
-
-        kasket_query = parse(:conditions => {:id => 1, :blog_id => 2})
-        assert_match(/blog_id=2\/id=1$/, kasket_query[:key])
-
-        kasket_query = parse(:conditions => {:id => 1, :title => 'title'})
-        assert_match(/id=1\/title='title'$/, kasket_query[:key])
-      end
-
-      should "generate multiple keys on IN queries" do
-        keys = parse(:conditions => {:id => [1,2]})[:key]
-        assert_instance_of(Array, keys)
-        assert_match(/id=1$/, keys[0])
-        assert_match(/id=2$/, keys[1])
-      end
-
-      context "when limit 1" do
-        should "add /first to the key if the index does not include id" do
-          assert_match(/title='a'\/first$/, parse(:conditions => {:title => 'a'}, :limit => 1)[:key])
-        end
-
-        should "not add /first to the key when the index includes id" do
-          assert_match(/id=1$/, parse(:conditions => {:id => 1}, :limit => 1)[:key])
-        end
-      end
-    end
-  end
-end