activerecord-futures 0.0.1 → 0.1.0

data/spec/in_action/future_count_execution_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe "future_count method" do
+  context "single value count" do
+    let(:relation) { Post.where("published_at < ?", Time.new(2013, 1, 1)) }
+    let(:count) { relation.future_count }
+    let(:count_sql) do
+      arel = relation.arel
+      arel.projections = []
+      arel.project("COUNT(*)")
+      arel.to_sql
+    end
+
+    before do
+      Post.create(published_at: Time.new(2012, 12, 10))
+      Post.create(published_at: Time.new(2012, 6, 23))
+      Post.create(published_at: Time.new(2013, 4, 5))
+    end
+
+    describe "#value" do
+      let(:calling_value) { -> { count.value } }
+
+      specify do
+        calling_value.should exec(1).query
+      end
+
+      specify do
+        calling_value.should exec_query(count_sql)
+      end
+
+      specify { count.value.should eq 2 }
+
+      context "executing it twice" do
+        before do
+          count.value
+        end
+
+        specify do
+          calling_value.should exec(0).queries
+        end
+
+        specify { count.value.should eq 2 }
+      end
+    end
+  end
+
+  context "grouped value count" do
+    let(:relation) { Comment.scoped }
+    let(:count) { relation.future_count(group: :post_id) }
+    let(:count_sql) do
+      arel = relation.arel
+      arel.projections = []
+      arel.project("COUNT(*) AS count_all")
+      arel.project("post_id AS post_id")
+      arel.group("post_id")
+      arel.to_sql
+    end
+
+    let(:post_1) { Post.create(published_at: Time.now) }
+    let(:post_2) { Post.create(published_at: Time.now) }
+
+    before do
+      Comment.create(post: post_1)
+      Comment.create(post: post_1)
+      Comment.create(post: post_2)
+      Comment.create(post: post_2)
+      Comment.create(post: post_2)
+    end
+
+    describe "#to_a" do
+      let(:calling_to_a) { -> { count.to_a } }
+
+      specify do
+        calling_to_a.should exec(1).query
+      end
+
+      specify do
+        calling_to_a.should exec_query(count_sql)
+      end
+
+      specify { count.to_a[post_1.id].should eq 2 }
+      specify { count.to_a[post_2.id].should eq 3 }
+
+      context "executing it twice" do
+        before do
+          count.to_a
+        end
+
+        specify do
+          calling_to_a.should exec(0).queries
+        end
+
+        specify { count.to_a[post_1.id].should eq 2 }
+        specify { count.to_a[post_2.id].should eq 3 }
+      end
+    end
+  end
+end

data/spec/in_action/future_fulfillment_spec.rb

@@ -5,7 +5,7 @@ module ActiveRecord::Futures
     subject { Future }
 
     context "when futurizing a relation" do
-      let!(:future) { User.where(name: "").future }
+      let!(:future) { Post.where(title: "Some post").future }
 
       its(:all) { should have(1).future }
 
@@ -21,14 +21,15 @@ module ActiveRecord::Futures
         context "the future" do
           subject { future }
 
-          it { should be_fulfilled }
+          it(nil, :supporting_adapter) { should be_fulfilled }
+          it(nil, :not_supporting_adapter) { should_not be_fulfilled }
         end
       end
     end
 
     context "when futurizing two relations" do
-      let!(:future) { User.where(name: "").future }
-      let!(:another_future) { Country.where(name: "").future }
+      let!(:future) { Post.where(title: "Some post").future }
+      let!(:another_future) { User.where(name: "Lenny").future }
 
       its(:all) { should have(2).futures }
 
@@ -46,16 +47,18 @@ module ActiveRecord::Futures
         its(:all) { should have(0).futures }
 
         context "the first relation future" do
-          specify { future.should be_fulfilled }
+          specify(nil, :supporting_adapter) { future.should be_fulfilled }
+          specify(nil, :not_supporting_adapter) { future.should_not be_fulfilled }
         end
 
         context "the other relation future" do
-          specify { another_future.should be_fulfilled }
+          specify(nil, :supporting_adapter) { another_future.should be_fulfilled }
+          specify(nil, :not_supporting_adapter) { another_future.should_not be_fulfilled }
         end
       end
 
       context "and executing another non futurized relation" do
-        let!(:normal_relation) { User.where(name: "") }
+        let!(:normal_relation) { User.where(name: "John") }
         before { normal_relation.to_a }
 
         its(:all) { should have(2).futures }

data/spec/in_action/future_pluck_execution_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe "future_pluck method" do
+  let(:relation) { Post.where("published_at < ?", Time.new(2013, 1, 1)) }
+  let(:pluck) { relation.future_pluck('title') }
+  let(:pluck_sql) do
+    arel = relation.arel
+    arel.projections = []
+    arel.project('title')
+    arel.to_sql
+  end
+
+  before do
+    Post.create(title: "Post 1", published_at: Time.new(2012, 12, 10))
+    Post.create(title: "Post 2", published_at: Time.new(2012, 6, 23))
+    Post.create(title: "Post 3", published_at: Time.new(2013, 4, 5))
+  end
+
+  describe "#to_a" do
+    let(:calling_to_a) { -> { pluck.to_a } }
+
+    specify do
+      calling_to_a.should exec(1).query
+    end
+
+    specify do
+      calling_to_a.should exec_query(pluck_sql)
+    end
+
+    specify { pluck.to_a.should eq ["Post 1", "Post 2"] }
+
+    context "executing it twice" do
+      before do
+        pluck.to_a
+      end
+
+      specify do
+        calling_to_a.should exec(0).queries
+      end
+
+      specify { pluck.to_a.should eq ["Post 1", "Post 2"] }
+    end
+  end
+end

data/spec/in_action/future_relation_execution_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe "future method" do
+
+  before do
+    Post.create(published_at: Time.new(2012, 12, 10))
+    Post.create(published_at: Time.new(2012, 6, 23))
+    Post.create(published_at: Time.new(2013, 4, 5))
+  end
+
+  def self.spec_relation(description, relation_lambda, &block)
+    context "with a sample relation that #{description}" do
+      let(:relation) { relation_lambda.call }
+      let(:future) { relation.future }
+
+      describe "#to_a" do
+        let(:calling_to_a) { lambda { future.to_a } }
+
+        specify do
+          calling_to_a.should exec(1).query
+        end
+
+        specify do
+          calling_to_a.should exec_query(relation.to_sql)
+        end
+
+        instance_eval(&block)
+
+        context "executing it twice" do
+          before do
+            future.to_a
+          end
+
+          specify do
+            calling_to_a.should exec(0).queries
+          end
+
+          instance_eval(&block)
+        end
+      end
+    end
+  end
+
+  spec_relation "filters by published_at", -> { Post.where("published_at < ?", Time.new(2013, 1, 1)) } do
+    specify { future.to_a.should have(2).posts }
+  end
+
+  spec_relation "limits by 10", -> { Post.limit(10) } do
+    specify { future.to_a.should have(3).posts }
+  end
+
+end

data/spec/models/comment.rb

@@ -0,0 +1,4 @@
+class Comment < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :post
+end

data/spec/models/post.rb

@@ -0,0 +1,3 @@
+class Post < ActiveRecord::Base
+  default_scope { where("published_at is not null") }
+end

data/spec/models/user.rb

@@ -1,2 +1,3 @@
 class User < ActiveRecord::Base
+  has_many :comments
 end

data/spec/spec_helper.rb

@@ -1,18 +1,47 @@
+require 'coveralls'
+Coveralls.wear!
+
 require 'activerecord-futures'
 
-config = {
-  adapter: "future_enabled_mysql2",
-  database: "test",
-  username: "root",
-  password: "root",
-  database: "activerecord_futures_test",
-  host: "localhost"
+configs = {
+  future_enabled_mysql2: {
+    adapter: "future_enabled_mysql2",
+    database: "activerecord_futures_test",
+    username: "root",
+    encoding: "utf8"
+  },
+  future_enabled_postgresql: {
+    adapter: "future_enabled_postgresql",
+    database: "activerecord_futures_test",
+    username: "postgres"
+  },
+  postgresql: {
+    adapter: "postgresql",
+    database: "activerecord_futures_test",
+    username: "postgres"
+  },
+  mysql2: {
+    adapter: "mysql2",
+    database: "activerecord_futures_test",
+    username: "root",
+    encoding: "utf8"
+  }
 }
 
+env_config = ENV['ADAPTER'].try(:to_sym)
+config_key = configs.keys.include?(env_config) ? env_config : :future_enabled_mysql2
+config = configs[config_key]
+puts "Using #{config_key} configuration"
+
 ActiveRecord::Base.establish_connection(config)
+supports_futures =
+  ActiveRecord::Base.connection.respond_to?(:supports_futures?) &&
+  ActiveRecord::Base.connection.supports_futures?
+
 require 'db/schema'
+Dir['./spec/models/**/*.rb'].each { |f| require f }
 
-Dir[File.join(File.dirname(__FILE__), 'models/**/*')].each { |f| require f }
+Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
 
 require 'rspec-spies'
 
@@ -20,13 +49,20 @@ RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
-
+  config.filter_run_excluding(supports_futures ? :not_supporting_adapter : :supporting_adapter)
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.
   #     --seed 1234
   config.order = 'random'
 
+  config.around do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+
   config.after do
     ActiveRecord::Futures::Future.clear
   end

data/spec/support/matchers/exec.rb

@@ -0,0 +1,66 @@
+RSpec::Matchers.define :exec do |expected|
+
+  match do |block|
+    query_count(&block) == expected
+  end
+
+  chain :queries do
+  end
+
+  chain :query do
+  end
+
+  description do
+    queries = expected == 1 ? "query" : "queries"
+    "exec #{expected} #{queries}"
+  end
+
+  failure_message_for_should do |actual|
+    "Expected to execute #{expected} queries, executed #{@query_counter.query_count}: #{@query_counter.queries}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "Expected to not execute #{expected} queries"
+  end
+
+  def query_count(&block)
+    @query_counter = QueryCounter.new
+    ActiveSupport::Notifications.subscribed(@query_counter.method(:call), 'sql.active_record', &block)
+    @query_counter.query_count
+  end
+end
+
+class QueryCounter
+  attr_accessor :query_count
+  attr_accessor :queries
+
+  IGNORED_SQL = [
+    /^PRAGMA (?!(table_info))/,
+    /^SELECT currval/,
+    /^SELECT CAST/,
+    /^SELECT @@IDENTITY/,
+    /^SELECT @@ROWCOUNT/,
+    /^SAVEPOINT/,
+    /^ROLLBACK TO SAVEPOINT/,
+    /^RELEASE SAVEPOINT/,
+    /^SHOW max_identifier_length/,
+    /SELECT attr.attname\n          FROM pg_attribute attr/,
+    /SHOW/
+  ]
+
+  def initialize
+    self.query_count = 0
+    self.queries = []
+  end
+
+  def call(name, start, finish, message_id, values)
+    # FIXME: this seems bad. we should probably have a better way to indicate
+    # the query was cached
+    unless 'CACHE' == values[:name]
+      unless IGNORED_SQL.any? { |r| values[:sql] =~ r }
+        self.query_count += 1
+        self.queries << values[:sql]
+      end
+    end
+  end
+end

data/spec/support/matchers/exec_query.rb

@@ -0,0 +1,23 @@
+RSpec::Matchers.define :exec_query do |expected|
+
+  match do |block|
+    query(&block) == expected
+  end
+
+  failure_message_for_should do |actual|
+    "Expected to execute #{expected}, got #{@query}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "Expected to not execute #{expected}, got #{actual}"
+  end
+
+  def query(&block)
+    query = lambda do |name, start, finish, message_id, values|
+      @query = values[:sql]
+    end
+    ActiveSupport::Notifications.subscribed(query, 'sql.active_record', &block)
+    @query
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-futures
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-12 00:00:00.000000000 Z
+date: 2013-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.2.13
+        version: 3.2.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.2.13
+        version: 3.2.11
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -59,6 +59,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.12.b1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.12.b1
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Save unnecessary round trips to the database
 email:
 - leoasis@gmail.com
@@ -68,27 +100,41 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - activerecord-futures.gemspec
+- lib/active_record/connection_adapters/future_enabled.rb
 - lib/active_record/connection_adapters/future_enabled_mysql2_adapter.rb
+- lib/active_record/connection_adapters/future_enabled_postgresql_adapter.rb
 - lib/active_record/futures.rb
 - lib/active_record/futures/delegation.rb
 - lib/active_record/futures/future.rb
 - lib/active_record/futures/future_calculation.rb
+- lib/active_record/futures/future_calculation_array.rb
+- lib/active_record/futures/future_calculation_value.rb
 - lib/active_record/futures/future_relation.rb
+- lib/active_record/futures/proxy.rb
 - lib/active_record/futures/query_recording.rb
 - lib/activerecord-futures.rb
 - lib/activerecord-futures/version.rb
 - spec/active_record/futures/future_relation_spec.rb
 - spec/active_record/futures/future_spec.rb
+- spec/active_record/futures/proxy_spec.rb
 - spec/db/schema.rb
+- spec/in_action/combination_of_futures_spec.rb
+- spec/in_action/future_count_execution_spec.rb
 - spec/in_action/future_fulfillment_spec.rb
-- spec/models/country.rb
+- spec/in_action/future_pluck_execution_spec.rb
+- spec/in_action/future_relation_execution_spec.rb
+- spec/models/comment.rb
+- spec/models/post.rb
 - spec/models/user.rb
 - spec/spec_helper.rb
+- spec/support/matchers/exec.rb
+- spec/support/matchers/exec_query.rb
 homepage: https://github.com/leoasis/activerecord-futures
 licenses: []
 post_install_message: 
@@ -116,9 +162,17 @@ summary: Fetch all queries at once from the database and save round trips.
 test_files:
 - spec/active_record/futures/future_relation_spec.rb
 - spec/active_record/futures/future_spec.rb
+- spec/active_record/futures/proxy_spec.rb
 - spec/db/schema.rb
+- spec/in_action/combination_of_futures_spec.rb
+- spec/in_action/future_count_execution_spec.rb
 - spec/in_action/future_fulfillment_spec.rb
-- spec/models/country.rb
+- spec/in_action/future_pluck_execution_spec.rb
+- spec/in_action/future_relation_execution_spec.rb
+- spec/models/comment.rb
+- spec/models/post.rb
 - spec/models/user.rb
 - spec/spec_helper.rb
+- spec/support/matchers/exec.rb
+- spec/support/matchers/exec_query.rb
 has_rdoc: