cequel 0.5.6 → 1.0.0.pre.1

data/spec/examples/model/properties_spec.rb

@@ -1,81 +1,128 @@
+require 'cequel/model'
 require File.expand_path('../spec_helper', __FILE__)
 
 describe Cequel::Model::Properties do
-  let(:post) { Post.new(:id => 1) }
 
-  it 'should have getter for key' do
-    post.id.should == 1
+  describe 'property accessors' do
+    model :Post do
+      key :permalink, :text
+      column :title, :text
+      list :tags, :text
+      set :categories, :text
+      map :shares, :text, :int
+
+      def downcased_title=(downcased_title)
+        self.title = downcased_title.titleize
+      end
+    end
+
+    it 'should provide accessor for key' do
+      Post.new { |post| post.permalink = 'big-data' }.permalink.
+        should == 'big-data'
+    end
+
+    it 'should cast key to correct value' do
+      Post.new { |post| post.permalink = 44 }.permalink.
+        should == '44'
+    end
+
+    it 'should have nil key if unset' do
+      Post.new.permalink.should be_nil
+    end
+
+    it 'should provide accessor for data column' do
+      Post.new { |post| post.title = 'Big Data' }.title.should == 'Big Data'
+    end
+
+    it 'should cast data column to correct value' do
+      Post.new { |post| post.title = 'Big Data'.force_encoding('US-ASCII') }.
+        title.encoding.name.should == 'UTF-8'
+    end
+
+    it 'should have nil data column value if unset' do
+      Post.new.title.should be_nil
+    end
+
+    it 'should allow setting attributes via #attributes=' do
+      Post.new.tap { |post| post.attributes = {:title => 'Big Data' }}.
+        title.should == 'Big Data'
+    end
+
+    it 'should use writers when setting attributes' do
+      Post.new.tap { |post| post.attributes = {:downcased_title => 'big data' }}.
+        title.should == 'Big Data'
+    end
+
+    it 'should take attribute arguments to ::new' do
+      Post.new(:downcased_title => 'big data').title.should == 'Big Data'
+    end
+
+    it 'should provide accessor for list column' do
+      Post.new { |post| post.tags = %w(one two three) }.tags.
+        should == %w(one two three)
+    end
+
+    it 'should cast values in list column' do
+      Post.new { |post| post.tags = Set[1, 2, 3] }.tags.
+        should == %w(1 2 3)
+    end
+
+    it 'should have empty list column value if unset' do
+      Post.new.tags.should == []
+    end
+
+    it 'should provide accessor for set column' do
+      Post.new { |post| post.categories = Set['Big Data', 'Cassandra'] }.
+        categories.should == Set['Big Data', 'Cassandra']
+    end
+
+    it 'should cast values to correct type' do
+      Post.new { |post| post.categories = [1, 2, 3] }.categories.
+        should == Set['1', '2', '3']
+    end
+
+    it 'should have empty set column value if present' do
+      Post.new.categories.should == Set[]
+    end
+
+    it 'should provide accessor for map column' do
+      Post.new { |post| post.shares = {'facebook' => 1, 'twitter' => 2}}.
+        shares.should == {'facebook' => 1, 'twitter' => 2}
+    end
+
+    it 'should cast values for map column' do
+      Post.new { |post| post.shares = [[:facebook, '1'], [:twitter, '2']] }.
+        shares.should == {'facebook' => 1, 'twitter' => 2}
+    end
+
+    it 'should set map column to empty hash by default' do
+      Post.new.shares.should == {}
+    end
+  end
+
+  describe 'configured property defaults' do
+    model :Post do
+      key :permalink, :text
+      column :title, :text, :default => 'New Post'
+      list :tags, :text, :default => ['new']
+      set :categories, :text, :default => Set['Big Data']
+      map :shares, :text, :int, :default => {'facebook' => 0}
+    end
+
+    it 'should respect default for data column' do
+      Post.new.title.should == 'New Post'
+    end
+
+    it 'should respect default for list column' do
+      Post.new.tags.should == ['new']
+    end
+
+    it 'should respect default for set column' do
+      Post.new.categories.should == Set['Big Data']
+    end
+
+    it 'should respect default for map column' do
+      Post.new.shares.should == {'facebook' => 0}
+    end
   end
-
-  it 'should return key alias from class' do
-    Post.key_alias.should == :id
-  end
-
-  it 'should return key for to_key' do
-    post.to_key.should == [1]
-  end
-
-  it 'should return param for to_param' do
-    post.persisted!
-    post.to_param.should == '1'
-  end
-
-  it 'should have getter and setter for column' do
-    post.title = 'Object/row mapping'
-    post.title.should == 'Object/row mapping'
-  end
-
-  it 'should have ? accessor for boolean column' do
-    post.published = true
-    post.published?.should be_true
-  end
-
-  it 'should not have ? accessor for non-boolean column' do
-    expect { post.title? }.to raise_error(NoMethodError)
-  end
-
-  it 'should expose column names on class' do
-    Post.column_names[0..1].should == [:id, :title]
-  end
-
-  it 'should expose column objects on class' do
-    Post.columns[0..1].map { |col| [col.name, col.type] }.
-      should == [[:id, :int], [:title, :varchar]]
-  end
-
-  it 'should expose #attributes' do
-    post.title = 'Cequel'
-    post.attributes.
-      should == {:id => 1, :title => 'Cequel'}.with_indifferent_access
-  end
-
-  it 'should not return nil values with attributes' do
-    post.title = nil
-    post.attributes.should == {:id => 1}.with_indifferent_access
-  end
-
-  it 'should set attributes' do
-    post.attributes = { :title => 'Cequel' }
-    post.id.should == 1
-    post.title.should == 'Cequel'
-  end
-
-  it 'should set attributes from constructor' do
-    Post.new(:id => 1, :title => 'Cequel').title.should == 'Cequel'
-  end
-
-  it 'should set default column values for new instances' do
-    Blog.new.published.should == true
-  end
-
-  it 'should use key to compare equality' do
-    Post.new(:id => 1).should == Post.new(:id => 1)
-    Post.new(:id => 1).should_not == Post.new(:id => 2)
-    Post.new(:id => 1).should_not == Blog.new(:id => 1)
-  end
-
-  it 'should use #generate_key method when implemented' do
-    Comment.new.id.should be_a(SimpleUUID::UUID)
-  end
-
 end

data/spec/examples/model/record_set_spec.rb

@@ -0,0 +1,285 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Cequel::Model::RecordSet do
+  model :Blog do
+    key :subdomain, :text
+    column :name, :text
+    column :description, :text
+  end
+
+  model :Post do
+    key :blog_subdomain, :text
+    key :permalink, :text
+    column :title, :text
+    column :body, :text
+    column :author_id, :uuid
+    list :tags, :text
+    set :categories, :text
+    map :shares, :text, :int
+  end
+
+  let(:subdomains) { [] }
+
+  before do
+    cequel.batch do
+      3.times do |i|
+        Blog.new do |blog|
+          subdomains << blog.subdomain = "blog-#{i}"
+          blog.name = "Blog #{i}"
+          blog.description = "This is Blog number #{i}"
+        end.save
+      end
+    end
+    cequel.batch do
+      5.times do |i|
+        cequel[:posts].insert(
+          :blog_subdomain => 'cassandra',
+          :permalink => "cequel#{i}",
+          :title => "Cequel #{i}",
+          :body => "Post number #{i}"
+        )
+        cequel[:posts].insert(
+          :blog_subdomain => 'postgres',
+          :permalink => "sequel#{i}",
+          :title => "Sequel #{i}"
+        )
+      end
+    end
+  end
+
+  describe '::find' do
+    context 'simple primary key' do
+      subject { Blog.find('blog-0') }
+
+      its(:subdomain) { should == 'blog-0' }
+      its(:name) { should == 'Blog 0' }
+
+      it { should be_persisted }
+      it { should_not be_transient }
+      specify { Blog.new.should_not be_persisted }
+      specify { Blog.new.should be_transient }
+
+      specify do
+        expect { Blog.find('bogus') }.
+          to raise_error(Cequel::Model::RecordNotFound)
+      end
+    end
+
+    context 'compound primary key' do
+      subject { Post['cassandra'].find('cequel0') }
+
+      its(:blog_subdomain) { should == 'cassandra' }
+      its(:permalink) { should == 'cequel0' }
+      its(:title) { should == 'Cequel 0' }
+
+      it { should be_persisted }
+      it { should_not be_transient }
+      specify { Post.new.should_not be_persisted }
+      specify { Post.new.should be_transient }
+
+      specify do
+        expect { Post['cequel'].find('bogus')}.
+          to raise_error(Cequel::Model::RecordNotFound)
+      end
+    end
+  end
+
+  describe '::[]' do
+    context 'simple primary key' do
+      subject { Blog['blog-0'] }
+
+      it 'should not query the database' do
+        disallow_queries!
+        subject.subdomain.should == 'blog-0'
+      end
+
+      it 'should lazily query the database when attribute accessed' do
+        subject.name.should == 'Blog 0'
+      end
+
+      it 'should get all eager-loadable attributes on first lazy load' do
+        subject.name
+        disallow_queries!
+        subject.description.should == 'This is Blog number 0'
+      end
+    end
+
+    context 'compound primary key' do
+      subject { Post['cassandra']['cequel0'] }
+
+      it 'should not query the database' do
+        expect(cequel).not_to receive(:execute)
+        subject.blog_subdomain.should == 'cassandra'
+        subject.permalink.should == 'cequel0'
+      end
+
+      it 'should lazily query the database when attribute accessed' do
+        subject.title.should == 'Cequel 0'
+      end
+
+      it 'should get all eager-loadable attributes on first lazy load' do
+        subject.title
+        expect(cequel).not_to receive(:execute)
+        subject.body.should == 'Post number 0'
+      end
+    end
+  end
+
+  describe '#all' do
+    it 'should return all the records' do
+      Blog.all.map(&:subdomain).should =~ subdomains
+    end
+  end
+
+  describe '#find_each' do
+    it 'should respect :batch_size argument' do
+      cequel.should_receive(:execute).twice.and_call_original
+      Blog.find_each(:batch_size => 2).map(&:subdomain).
+        should =~ subdomains
+    end
+    it 'should iterate over all keys' do
+      Post.find_each(:batch_size => 2).map(&:title).
+        should =~ (0...5).flat_map { |i| ["Cequel #{i}", "Sequel #{i}"] }
+    end
+  end
+
+  describe '#at' do
+    it 'should return partial collection' do
+      Post.at('cassandra').find_each(:batch_size => 2).map(&:title).
+        should == (0...5).map { |i| "Cequel #{i}" }
+    end
+  end
+
+  describe '#[]' do
+    it 'should create partial collection if not all keys specified' do
+      Post['cassandra'].find_each(:batch_size => 2).map(&:title).
+        should == (0...5).map { |i| "Cequel #{i}" }
+    end
+  end
+
+  describe '#/' do
+    it 'should behave like #at' do
+      (Post / 'cassandra').find_each(:batch_size => 2).map(&:title).
+        should == (0...5).map { |i| "Cequel #{i}" }
+    end
+  end
+
+  describe '#after' do
+    it 'should return collection after given key' do
+      Post.at('cassandra').after('cequel1').map(&:title).
+        should == (2...5).map { |i| "Cequel #{i}" }
+    end
+  end
+
+  describe '#from' do
+    it 'should return collection starting with given key' do
+      Post.at('cassandra').from('cequel1').map(&:title).
+        should == (1...5).map { |i| "Cequel #{i}" }
+    end
+
+    it 'should raise ArgumentError when called on partition key' do
+      expect { Post.from('cassandra') }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#before' do
+    it 'should return collection before given key' do
+      Post.at('cassandra').before('cequel3').map(&:title).
+        should == (0...3).map { |i| "Cequel #{i}" }
+    end
+  end
+
+  describe '#upto' do
+    it 'should return collection up to given key' do
+      Post.at('cassandra').upto('cequel3').map(&:title).
+        should == (0..3).map { |i| "Cequel #{i}" }
+    end
+  end
+
+  describe '#in' do
+    it 'should return collection with inclusive upper bound' do
+      Post.at('cassandra').in('cequel1'..'cequel3').map(&:title).
+        should == (1..3).map { |i| "Cequel #{i}" }
+    end
+
+    it 'should return collection with exclusive upper bound' do
+      Post.at('cassandra').in('cequel1'...'cequel3').map(&:title).
+        should == (1...3).map { |i| "Cequel #{i}" }
+    end
+  end
+
+  describe '#reverse' do
+    it 'should not call the database' do
+      disallow_queries!
+      Post.at('cassandra').reverse
+    end
+
+    it 'should return collection in reverse' do
+      Post.at('cassandra').reverse.map(&:title).
+        should == (0...5).map { |i| "Cequel #{i}" }.reverse
+    end
+
+    it 'should batch iterate over collection in reverse' do
+      Post.at('cassandra').reverse.find_each(:batch_size => 2).map(&:title).
+        should == (0...5).map { |i| "Cequel #{i}" }.reverse
+    end
+
+    it 'should raise an error if range key is a partition key' do
+      expect { Post.all.reverse }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe 'last' do
+    it 'should return the last instance' do
+      Post.at('cassandra').last.title.should == "Cequel 4"
+    end
+  end
+
+  describe '#first' do
+    context 'with no arguments' do
+      it 'should return an arbitrary record' do
+        subdomains.should include(Blog.first.subdomain)
+      end
+    end
+
+    context 'with a given size' do
+      subject { Blog.first(2) }
+
+      it { should be_a(Array) }
+      it { should have(2).items }
+      specify { (subject.map(&:subdomain) & subdomains).should have(2).items }
+    end
+  end
+
+  describe '#limit' do
+    it 'should return the number of blogs requested' do
+      Blog.limit(2).should have(2).entries
+    end
+  end
+
+  describe '#select' do
+    context 'with no block' do
+      subject { Blog.select(:subdomain, :name).first }
+
+      it { should be_loaded(:name) }
+      it { should_not be_loaded(:description) }
+      specify { expect { subject.name }.to_not raise_error }
+      specify { expect { subject.description }.
+        to raise_error(Cequel::Model::MissingAttributeError) }
+    end
+
+    context 'with block' do
+      it 'should delegate to the Enumerable method' do
+        Blog.all.select { |p| p.subdomain[/\d+/].to_i.even? }.
+          map(&:subdomain).should =~ %w(blog-0 blog-2)
+      end
+    end
+  end
+
+  describe '#count' do
+    it 'should count records' do
+      Blog.count.should == 3
+    end
+  end
+
+end