cequel 0.5.6 → 1.0.0.pre.1

data/spec/examples/model/associations_spec.rb

@@ -1,109 +1,119 @@
-require File.expand_path('../spec_helper', __FILE__)
+require_relative 'spec_helper'
 
 describe Cequel::Model::Associations do
 
+  model :Blog do
+    key :subdomain, :text
+    column :name, :text
+
+    has_many :posts
+  end
+
+  model :User do
+    key :login, :text
+    column :name, :text
+  end
+
+  model :Post do
+    belongs_to :blog
+    key :id, :uuid
+    column :title, :text
+  end
+
   describe '::belongs_to' do
-    let(:post) do
-      Post.new(:id => 1).tap { |post| post.blog_id = 2 }
-    end
+    let(:blog) { Blog.new { |blog| blog.subdomain = 'big-data' }}
+    let(:post) { Post.new }
 
-    before do
-      connection.stub(:execute).
-        with('SELECT * FROM blogs WHERE ? = ? LIMIT 1', :id, 2).
-        and_return result_stub(:id => 2, :name => 'Big Data Blog')
+    it 'should add parent key as first key' do
+      Post.key_column_names.first.should == :blog_subdomain
     end
 
-    it 'should query column family and return associated model' do
-      post.blog.name.should == 'Big Data Blog'
+    it 'should provide accessors for association object' do
+      post.blog = blog
+      post.blog.should == blog
     end
 
-    it 'should be nil if foreign key column is nil' do
-      post.blog_id = nil
-      post.blog.should be_nil
+    it 'should set parent key(s) when setting association object' do
+      post.blog = blog
+      post.blog_subdomain.should == 'big-data'
     end
 
-    it 'should memoize instance' do
-      post.blog
-      connection.should_not_receive :execute
-      post.blog
+    it 'should raise ArgumentError when parent is set without keys' do
+      blog.subdomain = nil
+      expect { post.blog = blog }.to raise_error(ArgumentError)
     end
 
-    it 'should unmemoize instance if foreign key is changed' do
-      post.blog
-      post.blog_id = 3
-      connection.stub(:execute).
-        with('SELECT * FROM blogs WHERE ? = ? LIMIT 1', :id, 3).
-        and_return result_stub(:id => 2, :name => 'Another Blog')
+    it 'should raise ArgumentError when parent is set to wrong class' do
+      expect { post.blog = post }.to raise_error(ArgumentError)
+    end
 
-      post.blog.name.should == 'Another Blog'
+    it 'should return Blog instance when parent key set directly' do
+      post.blog_subdomain = 'big-data'
+      post.blog.subdomain.should == 'big-data'
     end
 
-    it 'should provide setter for association' do
-      post.blog = Blog.new(:id => 3, :name => 'This blog')
-      post.blog_id.should == 3
+    it 'should not hydrate parent instance when creating from key' do
+      post.blog_subdomain = 'big-data'
+      disallow_queries!
+      post.blog.should_not be_loaded
     end
 
-    it 'should set foreign key to nil if association set to nil' do
-      post.blog = Blog.new(:id => 3, :name => 'This blog')
-      post.blog = nil
-      post.blog_id.should be_nil
+    it 'should not allow declaring belongs_to after key' do
+      expect do
+        Class.new(Cequel::Model::Base) do
+          key :permalink, :text
+          belongs_to :blog
+        end
+      end.to raise_error(Cequel::Model::InvalidRecordConfiguration)
     end
 
-    it 'should save transient associated object' do
-      now = Time.now
-      Time.stub(:now).and_return now
-      post.blog = Blog.new(:id => 3, :name => 'This blog')
-      connection.should_receive(:execute).
-        with "INSERT INTO blogs (?) VALUES (?)",
-          ['id', 'published', 'name', 'updated_at', 'created_at'],
-          [3, true, 'This blog', now, now]
-      connection.stub(:execute).
-        with "INSERT INTO posts (?) VALUES (?)", ['id', 'blog_id'], [post.id, 3]
-      post.save
+    it 'should not allow declaring belongs_to more than once' do
+      expect do
+        Class.new(Cequel::Model::Base) do
+          belongs_to :blog
+          belongs_to :user
+        end
+      end.to raise_error(Cequel::Model::InvalidRecordConfiguration)
     end
 
   end
 
   describe '::has_many' do
-    let(:blog) do
-      Blog.new(:id => 2)
+    let(:blog) { Blog.new { |blog| blog.subdomain = 'cequel' }.tap(&:save) }
+    let!(:posts) do
+      3.times.map do |i|
+        Post.new do |post|
+          post.blog = blog
+          post.id = CassandraCQL::UUID.new
+          post.title = "Post #{i}"
+        end.tap(&:save)
+      end
     end
-
-    before do
-      connection.stub(:execute).
-        with('SELECT * FROM posts WHERE ? = ?', :blog_id, 2).
-        and_return result_stub(
-          {:id => 1, :title => 'Cequel'},
-          {:id => 2, :title => 'Cequel revisited'}
-        )
+    let!(:other_posts) do
+      3.times.map do |i|
+        Post.new do |post|
+          post.blog_subdomain = 'mycat'
+          post.id = CassandraCQL::UUID.new
+          post.title = "My Cat #{i}"
+        end.tap(&:save)
+      end
     end
 
-    it 'should provide scope for associated instances' do
-      blog.posts.map { |post| post.title }.should ==
-        ['Cequel', 'Cequel revisited']
+    it 'should return scope of posts' do
+      blog.posts.map(&:title).should == ["Post 0", "Post 1", "Post 2"]
     end
 
-    it 'should destroy associated instances if :dependent => :destroy' do
-      connection.stub(:execute).with 'DELETE FROM blogs WHERE ? = ?', :id, 2
-      connection.should_receive(:execute).with 'DELETE FROM posts WHERE ? = ?', :id, 1
-      connection.should_receive(:execute).with 'DELETE FROM posts WHERE ? = ?', :id, 2
-      blog.destroy
+    it 'should retain scope when hydrated multiple times' do
+      blog.posts.map(&:id)
+      disallow_queries!
+      blog.posts.map(&:title).should == ["Post 0", "Post 1", "Post 2"]
     end
-  end
-
-  describe '::has_one' do
-    let(:post) { Post.new(:id => 1) }
 
-    before do
-      connection.stub(:execute).
-        with("SELECT * FROM assets WHERE ? = ? AND ? = ? LIMIT 1", :class_name, 'Photo', :post_id, 1).
-        and_return result_stub(
-          {:id => 1, :type => 'Photo', :url => 'http://outofti.me/glamour.jpg'},
-        )
-    end
-
-    it 'should look up association by foreign key' do
-      post.thumbnail.url.should == 'http://outofti.me/glamour.jpg'
+    it 'should reload when reload argument passed' do
+      blog.posts.map(&:id)
+      posts.first.destroy
+      blog.posts(true).map(&:title).should == ['Post 1', 'Post 2']
     end
   end
+
 end

data/spec/examples/model/callbacks_spec.rb

@@ -1,79 +1,86 @@
 require File.expand_path('../spec_helper', __FILE__)
 
 describe Cequel::Model::Callbacks do
-  let(:post) do
-    connection.stub(:execute).
-      with("SELECT * FROM posts WHERE ? = ? LIMIT 1", :id, 1).
-      and_return result_stub(:id => 1, :title => 'Cequel')
-    Post.find(1)
-  end
-
-  context 'on create' do
-    let(:post) { Post.new(:id => 1) }
-
-    before do
-      post.save
+  model :Post do
+    key :permalink, :text
+    column :title, :text
+
+    def self.track_callbacks(*events)
+      events.each do |event|
+        %w(before after).each do |position|
+          callback_name = :"#{position}_#{event}"
+          __send__(callback_name) do |post|
+            post.executed_callbacks << callback_name
+          end
+        end
+      end
     end
 
-    it 'should invoke save callback' do
-      post.should have_callback(:save)
-    end
-
-    it 'should invoke create callback' do
-      post.should have_callback(:create)
-    end
+    track_callbacks :save, :create, :update, :destroy
 
-    it 'should not invoke update callback' do
-      post.should_not have_callback(:update)
+    def executed_callbacks
+      @executed_callbacks ||= []
     end
 
-    it 'should not invoke destroy callback' do
-      post.should_not have_callback(:destroy)
-    end
   end
 
-  context 'on update' do
-    before do
-      post.save
-    end
-
-    it 'should invoke save callback' do
-      post.should have_callback(:save)
+  let(:new_post) do
+    Post.new do |post|
+      post.permalink = 'new-post'
+      post.title = 'New Post'
     end
+  end
 
-    it 'should not invoke create callback' do
-      post.should_not have_callback(:create)
+  let!(:existing_post) do
+    Post.new do |post|
+      post.permalink = 'existing-post'
+      post.title = 'Existing Post'
+    end.save!
+    Post.find('existing-post').tap do |post|
+      post.title = 'An Existing Post'
     end
+  end
 
-    it 'should invoke update callback' do
-      post.should have_callback(:update)
-    end
+  context 'on create' do
+    before { new_post.save! }
+    subject { new_post.executed_callbacks }
+
+    it { should include(:before_save) }
+    it { should include(:after_save) }
+    it { should include(:before_create) }
+    it { should include(:after_create) }
+    it { should_not include(:before_update) }
+    it { should_not include(:after_update) }
+    it { should_not include(:before_destroy) }
+    it { should_not include(:after_destroy) }
+  end
 
-    it 'should not invoke destroy callback' do
-      post.should_not have_callback(:destroy)
-    end
+  context 'on update' do
+    before { existing_post.save! }
+    subject { existing_post.executed_callbacks }
+
+    it { should include(:before_save) }
+    it { should include(:after_save) }
+    it { should_not include(:before_create) }
+    it { should_not include(:after_create) }
+    it { should include(:before_update) }
+    it { should include(:after_update) }
+    it { should_not include(:before_destroy) }
+    it { should_not include(:after_destroy) }
   end
 
   context 'on destroy' do
-    before do
-      connection.stub(:execute).with("DELETE FROM posts WHERE ? = ?", :id, 1)
-      post.destroy
-    end
-
-    it 'should not invoke save callback' do
-      post.should_not have_callback(:save)
-    end
-
-    it 'should not invoke create callback' do
-      post.should_not have_callback(:create)
-    end
-
-    it 'should not invoke update callback' do
-      post.should_not have_callback(:update)
-    end
-
-    it 'should invoke destroy callback' do
-      post.should have_callback(:destroy)
-    end
+    before { existing_post.destroy }
+
+    subject { existing_post.executed_callbacks }
+
+    it { should_not include(:before_save) }
+    it { should_not include(:after_save) }
+    it { should_not include(:before_create) }
+    it { should_not include(:after_create) }
+    it { should_not include(:before_update) }
+    it { should_not include(:after_update) }
+    it { should include(:before_destroy) }
+    it { should include(:after_destroy) }
   end
 end

data/spec/examples/model/list_spec.rb

@@ -0,0 +1,393 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Cequel::Model::List do
+  model :Post do
+    key :permalink, :text
+    column :title, :text
+    list :tags, :text
+  end
+
+  let(:scope) { cequel[:posts].where(:permalink => 'cequel') }
+  subject { scope.first }
+
+  let! :post do
+    Post.new do |post|
+      post.permalink = 'cequel'
+      post.tags = %w(one two)
+    end.tap(&:save)
+  end
+
+  let! :unloaded_post do
+    Post['cequel']
+  end
+
+  context 'new record' do
+    it 'should save list as-is' do
+      subject[:tags].should == %w(one two)
+    end
+  end
+
+  describe '#<<' do
+    it 'should add new items' do
+      post.tags << 'three' << 'four'
+      post.save
+      subject[:tags].should == %w(one two three four)
+    end
+
+    it 'should add new items atomically' do
+      scope.list_append(:tags, 'three')
+      post.tags << 'four' << 'five'
+      post.save
+      subject[:tags].should == %w(one two three four five)
+    end
+
+    it 'should add new items without reading' do
+      unloaded_post.tags << 'four' << 'five'
+      unloaded_post.save
+      unloaded_post.should_not be_loaded
+      subject[:tags].should == %w(one two four five)
+    end
+
+    it 'should add new items in memory when loaded' do
+      unloaded_post.tags << 'four' << 'five'
+      unloaded_post.tags.should == %w(one two four five)
+    end
+  end
+
+  describe '#[]=' do
+    before { scope.list_append(:tags, 'three') }
+
+    it 'should atomically replace a single element' do
+      post.tags[1] = 'TWO'
+      post.save
+      subject[:tags].should == %w(one TWO three)
+      post.tags.should == %w(one TWO)
+    end
+
+    it 'should replace an element without reading' do
+      cequel.should_not_receive :execute
+      unloaded_post.tags[1] = 'TWO'
+    end
+
+    it 'should persist the replaced element' do
+      unloaded_post.tags[1] = 'TWO'
+      unloaded_post.save
+      subject[:tags].should == %w(one TWO three)
+    end
+
+    it 'should apply local modifications when loaded later' do
+      unloaded_post.tags[1] = 'TWO'
+      unloaded_post.tags.should == %w(one TWO three)
+    end
+
+    it 'should atomically replace a given number of arguments' do
+      post.tags[0, 2] = 'One', 'Two'
+      post.save
+      subject[:tags].should == %w(One Two three)
+      post.tags.should == %w(One Two)
+    end
+
+    it 'should remove elements beyond positional arguments' do
+      scope.list_append(:tags, 'four')
+      post.tags[0, 3] = 'ONE'
+      post.save
+      subject[:tags].should == %w(ONE four)
+      post.tags.should == %w(ONE)
+    end
+
+    it 'should atomically replace a given range of elements' do
+      post.tags[0..1] = ['One', 'Two']
+      post.save
+      subject[:tags].should == %w(One Two three)
+      post.tags.should == %w(One Two)
+    end
+
+    it 'should remove elements beyond positional arguments' do
+      scope.list_append(:tags, 'four')
+      post.tags[0..2] = 'ONE'
+      post.save
+      subject[:tags].should == %w(ONE four)
+      post.tags.should == %w(ONE)
+    end
+  end
+
+  describe '#clear' do
+    it 'should clear all elements from the array' do
+      post.tags.clear
+      post.save
+      subject[:tags].should be_blank
+      post.tags.should == []
+    end
+
+    it 'should clear elements without loading' do
+      cequel.should_not receive(:execute)
+      unloaded_post.tags.clear
+    end
+
+    it 'should persist clear without loading' do
+      unloaded_post.tags.clear
+      unloaded_post.save
+      subject[:tags].should be_blank
+    end
+
+    it 'should apply local modifications post-hoc' do
+      unloaded_post.tags.clear
+      unloaded_post.tags.should == []
+    end
+  end
+
+  describe '#collect!' do
+    it 'should not respond' do
+      expect { post.tags.collect!(&:upcase) }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#concat' do
+    it 'should atomically concatenate elements' do
+      scope.list_append(:tags, 'three')
+      post.tags.concat(['four', 'five'])
+      post.save
+      subject[:tags].should == %w(one two three four five)
+      post.tags.should == %w(one two four five)
+    end
+
+    it 'should concat elements without loading' do
+      cequel.should_not_receive :execute
+      unloaded_post.tags.concat(['four', 'five'])
+    end
+
+    it 'should persist concatenated elements' do
+      unloaded_post.tags.concat(['four', 'five'])
+      unloaded_post.save
+      subject[:tags].should == %w(one two four five)
+    end
+
+    it 'should apply local modifications when loaded later' do
+      unloaded_post.tags.concat(['four', 'five'])
+      unloaded_post.tags.should == %w(one two four five)
+    end
+  end
+
+  describe '#delete' do
+    it 'should atomically delete all instances of an object' do
+      scope.list_append(:tags, 'three')
+      scope.list_append(:tags, 'two')
+      post.tags.delete('two')
+      post.save
+      subject[:tags].should == %w(one three)
+      post.tags.should == %w(one)
+    end
+
+    it 'should delete without loading' do
+      cequel.should_not_receive :execute
+      unloaded_post.tags.delete('two')
+    end
+
+    it 'should persist deletions without loading' do
+      unloaded_post.tags.delete('two')
+      unloaded_post.save
+      subject[:tags].should == %w(one)
+    end
+
+    it 'should modify local copy after the fact' do
+      unloaded_post.tags.delete('two')
+      unloaded_post.tags.should == %w(one)
+    end
+  end
+
+  describe '#delete_at' do
+    it 'should atomically delete from a given index' do
+      scope.list_append(:tags, ['three', 'four'])
+      post.tags.delete_at(1)
+      post.save
+      subject[:tags].should == %w(one three four)
+      post.tags.should == %w(one)
+    end
+
+    it 'should delete from a given index without reading' do
+      cequel.should_not_receive :execute
+      unloaded_post.tags.delete_at(1)
+    end
+
+    it 'should persist deletion from unloaded list' do
+      unloaded_post.tags.delete_at(1)
+      unloaded_post.save
+      subject[:tags].should == %w(one)
+    end
+
+    it 'should apply deletion after the fact' do
+      unloaded_post.tags.delete_at(1)
+      unloaded_post.tags.should == %w(one)
+    end
+  end
+
+  describe '#delete_if' do
+    it 'should not respond' do
+      expect { post.tags.delete_if { |tag| tag.start_with?('o') } }.
+        to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#fill' do
+    it 'should not respond' do
+      expect { post.tags.fill('seventy') }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#flatten!' do
+    it 'should not respond' do
+      expect { post.tags.flatten! }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#insert' do
+    it 'should not respond' do
+      expect { post.tags.insert(4, 'five') }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#keep_if' do
+    it 'should not respond' do
+      expect { post.tags.keep_if { |e| e.start_with?('o') } }.
+        to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#map!' do
+    it 'should not respond' do
+      expect { post.tags.map! { |e| e.upcase } }.
+        to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#pop' do
+    it 'should not respond' do
+      expect { post.tags.pop }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#push' do
+    it 'should add new items atomically' do
+      scope.list_append(:tags, 'three')
+      post.tags.push('four').push('five')
+      post.save
+      subject[:tags].should == %w(one two three four five)
+      post.tags.should == %w(one two four five)
+    end
+  end
+
+  describe '#reject!' do
+    it 'should not respond' do
+      expect { post.tags.reject! { |e| e.start_with?('o') } }.
+        to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#replace' do
+    it 'should just overwrite the whole array' do
+      scope.list_append(:tags, 'three')
+      post.tags.replace(%w(four five))
+      post.save
+      subject[:tags].should == %w(four five)
+      post.tags.should == %w(four five)
+    end
+
+    it 'should overwrite without reading' do
+      cequel.should_not_receive :execute
+      unloaded_post.tags.replace(%w(four five))
+    end
+
+    it 'should persist unloaded overwrite' do
+      unloaded_post.tags.replace(%w(four five))
+      unloaded_post.save
+      subject[:tags].should == %w(four five)
+    end
+
+    it 'should apply replace post-hoc' do
+      unloaded_post.tags.replace(%w(four five))
+      unloaded_post.tags.should == %w(four five)
+    end
+  end
+
+  describe '#reverse!' do
+    it 'should not respond' do
+      expect { post.tags.reverse! }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#rotate!' do
+    it 'should not respond' do
+      expect { post.tags.rotate! }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#select!' do
+    it 'should not respond' do
+      expect { post.tags.select! { |e| e.start_with?('o') } }.
+        to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#shift' do
+    it 'should not respond' do
+      expect { post.tags.shift }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#shuffle!' do
+    it 'should not respond' do
+      expect { post.tags.shuffle! }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#slice!' do
+    it 'should not respond' do
+      expect { post.tags.slice!(1, 2) }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#sort!' do
+    it 'should not respond' do
+      expect { post.tags.sort! }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#sort_by!' do
+    it 'should not respond' do
+      expect { post.tags.sort_by! { |e| e.reverse } }.
+        to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#uniq!' do
+    it 'should not respond' do
+      expect { post.tags.uniq! }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#unshift' do
+    it 'should atomically unshift' do
+      scope.list_prepend(:tags, 'zero')
+      post.tags.unshift('minustwo', 'minusone')
+      post.save
+      subject[:tags].should == %w(minustwo minusone zero one two)
+      post.tags.should == %w(minustwo minusone one two)
+    end
+
+    it 'should unshift without reading' do
+      cequel.should_not_receive :execute
+      unloaded_post.tags.unshift('minustwo', 'minusone')
+    end
+
+    it 'should persist unloaded unshift' do
+      unloaded_post.tags.unshift('minustwo', 'minusone')
+      unloaded_post.save
+      subject[:tags].should == %w(minustwo minusone one two)
+    end
+
+    it 'should apply unshift after the fact' do
+      unloaded_post.tags.unshift('minustwo', 'minusone')
+      unloaded_post.tags.should == %w(minustwo minusone one two)
+    end
+  end
+end