kashmir 0.1

data/test/activerecord_tricks_test.rb

@@ -0,0 +1,54 @@
+require 'ar_test_helper'
+
+describe 'ActiveRecord performance tricks' do
+
+  before(:all) do
+    TestData.create_tom
+    TestData.create_netto
+  end
+
+  describe "Query preload to avoid N+1 queries" do
+
+    it 'tries to preload records whenever possible' do
+      selects = track_queries do
+        AR::Chef.all.each do |chef|
+          chef.recipes.to_a
+        end
+      end
+      # SELECT * FROM chefs
+      # SELECT "recipes".* FROM "recipes" WHERE "recipes"."chef_id" = ?
+      # SELECT "recipes".* FROM "recipes" WHERE "recipes"."chef_id" = ?
+      assert_equal 3, selects.size
+
+      selects = track_queries do
+        AR::Chef.all.represent([:recipes])
+      end
+      # SELECT "chefs".* FROM "chefs"
+      # SELECT "recipes".* FROM "recipes" WHERE "recipes"."chef_id" IN (1, 2)
+      assert_equal 2, selects.size
+    end
+
+    it 'preloads queries per each level in the tree' do
+      selects = track_queries do
+        AR::Chef.all.each do |chef|
+          chef.recipes.each do |recipe|
+            recipe.ingredients.to_a
+          end
+        end
+      end
+      # SELECT "chefs".* FROM "chefs"
+      # (2x) SELECT "recipes".* FROM "recipes" WHERE "recipes"."chef_id" = ?
+      # (4x) SELECT "ingredients".* FROM "ingredients" INNER JOIN "recipes_ingredients" ...
+      assert_equal 7, selects.size
+
+      selects = track_queries do
+        AR::Chef.all.represent([ :recipes => [ :ingredients => [:name] ] ])
+      end
+      # SELECT "chefs".* FROM "chefs"
+      # SELECT "recipes".* FROM "recipes" WHERE "recipes"."chef_id" IN (1, 2)
+      # SELECT "recipes_ingredients".* FROM "recipes_ingredients" WHERE "recipes_ingredients"."recipe_id" IN (1, 2, 3, 4)
+      # SELECT "ingredients".* FROM "ingredients" WHERE "ingredients"."id" IN (1, 2, 3, 4, 5, 6, 7, 8)
+      assert_equal 4, selects.size
+    end
+  end
+end

data/test/ar_test_helper.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+require 'minitest/around'
+
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+require 'support/schema'
+require 'support/ar_models'
+require 'support/factories'
+
+
+class Minitest::Test
+  def around(&block)
+    ActiveRecord::Base.transaction do
+      block.call
+      raise ActiveRecord::Rollback
+    end
+  end
+end
+
+def track_queries
+  selects = []
+  queries_collector = lambda do |name, start, finish, id, payload|
+    selects << payload
+  end
+
+  ActiveRecord::Base.connection.clear_query_cache
+  ActiveSupport::Notifications.subscribed(queries_collector, 'sql.active_record') do
+    yield
+  end
+
+  selects.map { |sel| sel[:sql] }
+end

data/test/caching_test.rb

@@ -0,0 +1,197 @@
+require 'ar_test_helper'
+
+describe 'Caching' do
+
+  before(:all) do
+
+    Kashmir.init(
+      cache_client: Kashmir::Caching::Memory.new
+    )
+
+    TestData.create_tom
+    @restaurant = AR::Restaurant.find_by_name('Chef Tom Belly Burgers')
+  end
+
+  before(:each) do
+    Kashmir.caching.flush!
+  end
+
+  def from_cache(definition, model)
+    Kashmir.caching.from_cache(definition, model)
+  end
+
+  describe 'flat data' do
+    it 'loads the same exact data from cache' do
+      representation = @restaurant.represent([:name])
+      @restaurant.reload
+      cached_representation = @restaurant.represent([:name])
+      assert_equal representation, cached_representation
+    end
+
+    it 'stores the data in cache' do
+      representation = @restaurant.represent([:name])
+      cached_representation = from_cache([:name], @restaurant)
+      assert_equal representation, cached_representation
+    end
+  end
+
+  describe 'references to other representations' do
+    it 'does not perform the same query twice' do
+      selects = track_queries do
+        @restaurant.represent([:name, :owner])
+      end
+      assert_equal 1, selects.size
+
+      # clear active record cache for this instance
+      @restaurant.reload
+      selects = track_queries do
+        @restaurant.represent([:name, :owner])
+      end
+      assert_equal 0, selects.size
+    end
+
+    it 'loads the same exact data from cache' do
+      representation = @restaurant.represent([:name, :owner])
+      @restaurant.reload
+      cached_representation = @restaurant.represent([:name, :owner])
+      assert_equal representation, cached_representation
+    end
+
+    it 'stores the data in cache at every level' do
+      representation = @restaurant.represent([:name, owner: [:name] ])
+      cached_restaurant_with_chef = from_cache([:name, owner: [ :name ]], @restaurant)
+
+      assert_equal representation, cached_restaurant_with_chef
+
+      chef = @restaurant.owner
+      cached_chef = from_cache([:name], chef)
+
+      assert_equal cached_chef, representation[:owner]
+    end
+  end
+
+  describe 'nesting' do
+    before(:all) do
+      @chef = @restaurant.owner
+      @chef.reload
+    end
+
+    it 'caches at every level' do
+      representation = @chef.represent([:name, :restaurant =>[ :name, :rating =>[ :value ]]])
+      fully_cached_chef = from_cache([:name, :restaurant =>[ :name, :rating =>[ :value ]]], @chef)
+      assert_equal representation, fully_cached_chef
+
+      fully_cached_restaurant = from_cache([ :name, :rating => [:value] ], @restaurant)
+      assert_equal representation[:restaurant], fully_cached_restaurant
+
+      cached_rating = from_cache([:value], @restaurant.rating)
+      assert_equal representation[:restaurant][:rating], cached_rating
+
+      assert_equal 3, Kashmir.caching.keys.size
+    end
+
+    it 'tries to hit the cache at every level' do
+      selects = track_queries do
+        representation = @chef.represent([:name, :restaurant =>[ :name, :rating =>[ :value ]]])
+      end
+      #  SELECT  "restaurants".* FROM "restaurants" WHERE "restaurants"."owner_id" = ? LIMIT 1
+      #  SELECT  "ratings".* FROM "ratings" WHERE "ratings"."restaurant_id" = ? LIMIT 1
+      assert_equal selects.size, 2
+
+      @chef.reload
+      selects = track_queries do
+        representation = @chef.represent([:name, :restaurant =>[ :name, :rating =>[ :value ]]])
+      end
+      assert_equal selects.size, 0
+    end
+
+    it 'tries to fill holes in the cache graph' do
+      definition = [:name, :restaurant =>[ :name, :rating =>[ :value ]]]
+      representation = @chef.represent(definition)
+      Kashmir.caching.clear(definition, @chef)
+
+      assert_equal 2, Kashmir.caching.keys.size
+
+      @chef.reload
+      selects = track_queries do
+        @chef.represent(definition)
+      end
+      # ratings is still cached
+      # SELECT  "restaurants".* FROM "restaurants" WHERE "restaurants"."owner_id" = ? LIMIT 1
+      assert_equal selects.size, 1
+    end
+  end
+
+  describe 'collections' do
+    it 'caches every item' do
+      presented_recipes = AR::Recipe.all.represent([:title])
+
+      cached_keys = %w(
+        presenter:AR::Recipe:1:[:title]
+        presenter:AR::Recipe:2:[:title]
+      )
+
+      assert_equal cached_keys, Kashmir.caching.keys
+    end
+
+    it 'presents from cache' do
+      selects = track_queries do
+        AR::Recipe.all.represent([:title, :ingredients => [:name]])
+      end
+      # SELECT "recipes_ingredients".* FROM "recipes_ingredients" WHERE "recipes_ingredients"."recipe_id" IN (1, 2)
+      # SELECT "ingredients".* FROM "ingredients" WHERE "ingredients"."id" IN (1, 2, 3, 4)
+      assert_equal 3, selects.size
+
+      selects = track_queries do
+        AR::Recipe.all.represent([:title, :ingredients => [:name]])
+      end
+      # SELECT "recipes".* FROM "recipes"
+      assert_equal 1, selects.size
+
+      cache_keys = [
+        "presenter:AR::Ingredient:1:[:name]",
+        "presenter:AR::Ingredient:2:[:name]",
+        "presenter:AR::Recipe:1:[:title, {:ingredients=>[:name]}]",
+        "presenter:AR::Ingredient:3:[:name]",
+        "presenter:AR::Ingredient:4:[:name]",
+        "presenter:AR::Recipe:2:[:title, {:ingredients=>[:name]}]"
+      ]
+
+      assert_equal cache_keys, Kashmir.caching.keys
+    end
+  end
+
+  describe 'misc' do
+
+    it 'does not cache already cached results' do
+      @restaurant.represent([:name])
+      assert_equal 1, Kashmir.caching.keys.size
+
+      Kashmir.caching.expects(:store_presenter).never
+      @restaurant.represent([:name])
+    end
+
+    describe 'skipping cache' do
+      # see current_customer_count in test/support/ar_models.rb
+
+      before(:each) do
+        @restaurant.update_attributes(current_customer_count: 10)
+        @representation = @restaurant.represent([:name, :current_customer_count])
+      end
+
+      it 'still renders everything normally' do
+        assert_equal @representation, { name: 'Chef Tom Belly Burgers', current_customer_count: 10 }
+      end
+
+      it 'does not include that field in the key' do
+        assert_equal %w(presenter:AR::Restaurant:1:[:name]), Kashmir.caching.keys
+      end
+
+      it 'does not insert value in the cached results' do
+        assert_nil Kashmir.caching.from_cache([:name, :current_customar_count], @restaurant)
+        assert_equal Kashmir.caching.from_cache([:name], @restaurant), { name: 'Chef Tom Belly Burgers' }
+      end
+    end
+
+  end
+end

data/test/dsl_test.rb

@@ -0,0 +1,162 @@
+require 'test_helper'
+
+describe Kashmir do
+
+  module DSLTesting
+    class Recipe < OpenStruct
+      include Kashmir
+
+      representations do
+        rep(:num_steps)
+        rep(:title)
+        rep(:chef)
+        rep(:ingredients)
+      end
+    end
+
+    class Chef < OpenStruct
+      include Kashmir
+
+      representations do
+        rep(:full_name)
+      end
+
+      def full_name
+        "#{first_name} #{last_name}"
+      end
+    end
+
+    class SimpleRecipeRepresenter
+      include Kashmir::Dsl
+
+      prop :num_steps
+      prop :title
+    end
+
+    class ChefRepresenter
+      include Kashmir::Dsl
+
+      prop :full_name
+    end
+
+    class RecipeWithChefRepresenter
+      include Kashmir::Dsl
+
+      prop :title
+      embed :chef, ChefRepresenter
+    end
+  end
+
+  before do
+    @chef    = DSLTesting::Chef.new(first_name: 'Netto', last_name: 'Farah')
+    @brisket = DSLTesting::Recipe.new(title: 'BBQ Brisket', num_steps: 2, chef: @chef)
+  end
+
+  it 'translates to representation definitions' do
+    definitions = DSLTesting::SimpleRecipeRepresenter.definitions
+    assert_equal definitions, [:num_steps, :title]
+  end
+
+  it 'generates the same representations as hardcoded definitions' do
+    cooked_brisket = @brisket.represent([:num_steps, :title])
+    assert_equal cooked_brisket, { title: 'BBQ Brisket', num_steps: 2 }
+    assert_equal cooked_brisket, @brisket.represent(DSLTesting::SimpleRecipeRepresenter.definitions)
+  end
+
+  it 'generates nested representations' do
+    brisket_with_chef = @brisket.represent([:title, { :chef => [:full_name] }])
+    assert_equal brisket_with_chef, {
+      title: 'BBQ Brisket',
+      chef: {
+        full_name: 'Netto Farah'
+      }
+    }
+
+    assert_equal brisket_with_chef, @brisket.represent(DSLTesting::RecipeWithChefRepresenter.definitions)
+  end
+
+  describe 'Nested inline representations' do
+
+    module DSLTesting
+      class RecipeWithInlineChefRepresenter
+        include Kashmir::Dsl
+
+        prop :title
+
+        inline :chef do
+          prop :full_name
+        end
+      end
+
+      class Ingredient < OpenStruct
+        include Kashmir
+
+        representations do
+          rep(:name)
+          rep(:quantity)
+        end
+      end
+    end
+
+    it 'generates nested representations' do
+      brisket_with_chef = @brisket.represent([:title, { :chef => [:full_name] }])
+      assert_equal brisket_with_chef, {
+        title: 'BBQ Brisket',
+        chef: {
+          full_name: 'Netto Farah'
+        }
+      }
+
+      assert_equal brisket_with_chef, @brisket.represent(DSLTesting::RecipeWithInlineChefRepresenter.definitions)
+    end
+  end
+
+  describe 'Collections' do
+    module DSLTesting
+      class RecipeWithIngredientsRepresenter
+        include Kashmir::Dsl
+
+        prop :title
+
+        inline :ingredients do
+          prop :name
+          prop :quantity
+        end
+      end
+    end
+
+    it 'generates nested collections' do
+      @brisket.ingredients = [
+        DSLTesting::Ingredient.new(name: 'Beef', quantity: '8oz'),
+        DSLTesting::Ingredient.new(name: 'BBQ Sauce', quantity: 'plenty!'),
+      ]
+
+      cooked_brisket = {
+        title: 'BBQ Brisket',
+        ingredients: [
+          { name: 'Beef', quantity: '8oz' },
+          { name: 'BBQ Sauce', quantity: 'plenty!' }
+        ]
+      }
+
+      assert_equal cooked_brisket, @brisket.represent(DSLTesting::RecipeWithIngredientsRepresenter.definitions)
+    end
+  end
+
+  describe "Kashmir.props" do
+
+    module DSLTesting
+
+      class MultiPropRecipeRepresenter
+        include Kashmir::Dsl
+
+        props :num_steps, :title
+      end
+    end
+
+    it 'allows the client to specify many props at once' do
+      definitions = DSLTesting::MultiPropRecipeRepresenter.definitions
+      assert_equal definitions, [:num_steps, :title]
+    end
+  end
+end