cequel 0.5.6 → 1.0.0.pre.1

data/spec/examples/model/schema_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Cequel::Model::Schema do
+  after { cequel.schema.drop_table(:posts) }
+  subject { cequel.schema.read_table(:posts) }
+
+  let(:model) do
+    Class.new(Cequel::Model::Base) do
+      self.table_name = 'posts'
+
+      key :permalink, :text
+      column :title, :text
+      list :categories, :text
+      set :tags, :text
+      map :trackbacks, :timestamp, :text
+      table_property :comment, 'Blog Posts'
+    end
+  end
+
+  context 'new model with simple primary key' do
+    before { model.synchronize_schema }
+
+    its(:partition_keys) { should == [Cequel::Schema::Column.new(:permalink, :text)] }
+    its(:data_columns) { should include(Cequel::Schema::Column.new(:title, :text)) }
+    its(:data_columns) { should include(Cequel::Schema::List.new(:categories, :text)) }
+    its(:data_columns) { should include(Cequel::Schema::Set.new(:tags, :text)) }
+    its(:data_columns) { should include(Cequel::Schema::Map.new(:trackbacks, :timestamp, :text)) }
+    specify { subject.property(:comment).should == 'Blog Posts' }
+  end
+
+  context 'existing model with additional attribute' do
+    before do
+      cequel.schema.create_table :posts do
+        key :permalink, :text
+        column :title, :text
+        list :categories, :text
+        set :tags, :text
+      end
+      model.synchronize_schema
+    end
+
+    its(:data_columns) { should include(Cequel::Schema::Map.new(:trackbacks, :timestamp, :text)) }
+  end
+end

data/spec/examples/model/serialization_spec.rb

@@ -1,20 +1,26 @@
-require File.expand_path('../spec_helper', __FILE__)
+require_relative 'spec_helper'
 
-describe 'Serialization' do
-  let(:post) { Post.new(:id => 1, :title => 'Cequel') }
+describe 'serialization' do
+  model :Post do
+    key :blog_subdomain, :text
+    key :id, :uuid
+    column :title, :text
+    column :body, :text
+  end
+
+  uuid :id
 
-  it 'should serialize to JSON' do
-    post.to_json.should ==
-      {'post' => {'id' => 1, 'title' => 'Cequel'}}.to_json
+  let(:attributes) do
+    {
+      blog_subdomain: 'big-data',
+      id: id,
+      title: 'Cequel',
+    }
   end
 
-  it 'should serialize to XML' do
-    post.to_xml.should == <<XML
-<?xml version="1.0" encoding="UTF-8"?>
-<post>
-  <id type="integer">1</id>
-  <title>Cequel</title>
-</post>
-XML
+  it 'should provide JSON serialization' do
+    Post.include_root_in_json = false
+    Post.new(attributes).as_json.symbolize_keys.
+      should == attributes.merge(body: nil)
   end
 end

data/spec/examples/model/set_spec.rb

@@ -0,0 +1,133 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Cequel::Model::Set do
+  model :Post do
+    key :permalink, :text
+    column :title, :text
+    set :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 = Set['one', 'two']
+    end.tap(&:save)
+  end
+
+  let! :unloaded_post do
+    Post['cequel']
+  end
+
+  context 'new record' do
+    it 'should save set as-is' do
+      subject[:tags].should == Set['one', 'two']
+    end
+  end
+
+  describe 'atomic modification' do
+    before { scope.set_add(:tags, 'three') }
+
+    describe '#add' do
+      it 'should add atomically' do
+        post.tags.add('four')
+        post.save
+        subject[:tags].should == Set['one', 'two', 'three', 'four']
+        post.tags.should == Set['one', 'two', 'four']
+      end
+
+      it 'should add without reading' do
+        max_statements! 2
+        unloaded_post.tags.add('four')
+        unloaded_post.save
+        subject[:tags].should == Set['one', 'two', 'three', 'four']
+      end
+
+      it 'should apply add post-hoc' do
+        unloaded_post.tags.add('four')
+        unloaded_post.tags.should == Set['one', 'two', 'three', 'four']
+      end
+    end
+
+    describe '#clear' do
+      it 'should clear atomically' do
+        post.tags.clear
+        post.save
+        subject[:tags].should be_blank
+        post.tags.should == Set[]
+      end
+
+      it 'should clear without reading' do
+        max_statements! 2
+        unloaded_post.tags.clear
+        unloaded_post.save
+        subject[:tags].should be_blank
+      end
+
+      it 'should apply clear post-hoc' do
+        unloaded_post.tags.clear
+        unloaded_post.tags.should == Set[]
+      end
+    end
+
+    describe '#delete' do
+      it 'should delete atomically' do
+        post.tags.delete('two')
+        post.save
+        subject[:tags].should == Set['one', 'three']
+        post.tags.should == Set['one']
+      end
+
+      it 'should delete without reading' do
+        max_statements! 2
+        unloaded_post.tags.delete('two')
+        unloaded_post.save
+        subject[:tags].should == Set['one', 'three']
+      end
+
+      it 'should apply delete post-hoc' do
+        unloaded_post.tags.delete('two')
+        unloaded_post.tags.should == Set['one', 'three']
+      end
+    end
+
+    describe '#replace' do
+      it 'should replace atomically' do
+        post.tags.replace(Set['a', 'b'])
+        post.save
+        subject[:tags].should == Set['a', 'b']
+        post.tags.should == Set['a', 'b']
+      end
+
+      it 'should replace without reading' do
+        max_statements! 2
+        unloaded_post.tags.replace(Set['a', 'b'])
+        unloaded_post.save
+        subject[:tags].should == Set['a', 'b']
+      end
+
+      it 'should apply delete post-hoc' do
+        unloaded_post.tags.replace(Set['a', 'b'])
+        unloaded_post.tags.should == Set['a', 'b']
+      end
+    end
+
+    specify { expect { post.tags.add?('three') }.to raise_error(NoMethodError) }
+    specify { expect { post.tags.collect!(&:upcase) }.
+      to raise_error(NoMethodError) }
+    specify { expect { post.tags.delete?('two') }.to raise_error(NoMethodError) }
+    specify { expect { post.tags.delete_if { |s| s.starts_with?('t') }}.
+      to raise_error(NoMethodError) }
+    specify { expect { post.tags.flatten! }.to raise_error(NoMethodError) }
+    specify { expect { post.tags.keep_if { |s| s.starts_with?('t') }}.
+      to raise_error(NoMethodError) }
+    specify { expect { post.tags.map!(&:upcase) }.
+      to raise_error(NoMethodError) }
+    specify { expect { post.tags.reject! { |s| s.starts_with?('t') }}.
+      to raise_error(NoMethodError) }
+    specify { expect { post.tags.select! { |s| s.starts_with?('t') }}.
+      to raise_error(NoMethodError) }
+  end
+end

data/spec/examples/model/spec_helper.rb

@@ -1,12 +1,2 @@
 require File.expand_path('../../spec_helper', __FILE__)
 require 'cequel/model'
-
-Dir.glob(File.join(File.dirname(__FILE__), '../../models/**/*.rb')).each do |file|
-  require file
-end
-
-RSpec.configure do |config|
-  config.before :each do
-    Cequel::Model.keyspace.connection = connection
-  end
-end

data/spec/examples/model/validations_spec.rb

@@ -1,86 +1,99 @@
-require File.expand_path('../spec_helper', __FILE__)
+require_relative 'spec_helper'
 
 describe Cequel::Model::Validations do
+  model :Post do
+    key :permalink, :text
+    column :title, :text
+    column :body, :text
+
+    validates :title, :presence => true
+    before_validation { |post| post.called_validate_callback = true }
+
+    attr_accessor :called_validate_callback
+  end
+
+  let(:invalid_post) do
+    Post.new do |post|
+      post.permalink = 'invalid'
+      post.body = 'This is an invalid post.'
+    end
+  end
+  let(:valid_post) do
+    Post.new do |post|
+      post.permalink = 'valid'
+      post.title = 'Valid Post'
+    end
+  end
+  let(:unloaded_post) { Post['unloaded'] }
+
   describe '#valid?' do
     it 'should be false if model is not valid' do
-      Post.new(:id => 1, :require_title => true).should_not be_valid
+      invalid_post.should_not be_valid
     end
 
     it 'should be true if model is valid' do
-      Post.new(:id => 1, :require_title => true, :title => 'Cequel').should be_valid
+      valid_post.should be_valid
     end
   end
 
   describe '#save' do
     it 'should return false and not persist model if invalid' do
-      Post.new(:id => 1, :body => 'Cequel', :require_title => true).save.should be_false
+      invalid_post.save.should be_false
     end
 
     it 'should return true and persist model if valid' do
-      connection.should_receive(:execute).
-        with "INSERT INTO posts (?) VALUES (?)", ['id', 'title'], [1, 'Cequel']
+      valid_post.save.should be_true
+      Post.find('valid').title.should == 'Valid Post'
+    end
 
-      Post.new(:id => 1, :title => 'Cequel', :require_title => true).save.should be_true
+    it 'should bypass validations if :validate => false is passed' do
+      invalid_post.save(:validate => false).should be_true
+      Post.find('invalid').body.should == 'This is an invalid post.'
     end
   end
 
   describe '#save!' do
     it 'should raise error and not persist model if invalid' do
-      expect do
-        Post.new(:id => 1, :body => 'Cequel', :require_title => true).save!
-      end.to raise_error(Cequel::Model::RecordInvalid)
+      expect { invalid_post.save!  }.
+        to raise_error(Cequel::Model::RecordInvalid)
     end
 
     it 'should persist model and return self if valid' do
-      connection.should_receive(:execute).
-        with "INSERT INTO posts (?) VALUES (?)", ['id', 'title'], [1, 'Cequel']
-
-      post = Post.new(:id => 1, :title => 'Cequel', :require_title => true)
-      post.save!.should == post
+      expect { valid_post.save! }.to_not raise_error
+      Post.find(valid_post.permalink).title.should == 'Valid Post'
     end
   end
 
   describe '#update_attributes!' do
-    let(:post) do
-      connection.stub(:execute).with("SELECT * FROM posts WHERE ? = ? LIMIT 1", :id, 1).
-        and_return result_stub(:id => 1, :blog_id => 1, :title => 'Cequel')
-      Post.find(1)
-    end
-
-    it 'should change attributes and save them if valid' do
-      connection.should_receive(:execute).
-        with "UPDATE posts SET ? = ? WHERE ? = ?", 'body', 'Cequel cequel', :id, 1
-      post.update_attributes!(:body => 'Cequel cequel')
+    it 'should raise error and not update data in the database' do
+      expect { invalid_post.update_attributes!(:body => 'My Post') }.
+        to raise_error(Cequel::Model::RecordInvalid)
     end
 
-    it 'should raise error if not valid' do
-      post.require_title = true
-      expect { post.update_attributes!(:title => nil) }.
-        to raise_error(Cequel::Model::RecordInvalid)
+    it 'should return successfully and update data in the database if valid' do
+      invalid_post.update_attributes!(:title => 'My Post')
+      Post.find(invalid_post.permalink).title.should == 'My Post'
     end
   end
 
   describe '::create!' do
     it 'should raise RecordInvalid and not persist model if invalid' do
       expect do
-        Post.create!(:id => 1, :body => 'Cequel', :require_title => true)
+        Post.create!(:permalink => 'cequel', :body => 'Cequel')
       end.to raise_error(Cequel::Model::RecordInvalid)
     end
 
-    it 'should and return model if valid' do
-      connection.should_receive(:execute).
-        with "INSERT INTO posts (?) VALUES (?)", ['id', 'title'], [1, 'Cequel']
-
-      Post.create!(:id => 1, :title => 'Cequel', :require_title => true).
-        title.should == 'Cequel'
+    it 'should persist record to database if valid' do
+      Post.create!(:permalink => 'cequel', :title => 'Cequel')
+      Post.find('cequel').title.should == 'Cequel'
     end
   end
 
   describe 'callbacks' do
     it 'should call validation callbacks' do
-      post = Post.new(:id => 1)
+      post = Post.new(:title => 'cequel')
       post.valid?
-      post.should have_callback(:validation)
+      post.called_validate_callback.should be_true
     end
   end
 end

data/spec/examples/schema/table_reader_spec.rb

@@ -0,0 +1,328 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Cequel::Schema::TableReader do
+
+  after do
+    cequel.schema.drop_table(:posts)
+  end
+
+  let(:table) { cequel.schema.read_table(:posts) }
+
+  describe 'reading simple key' do
+    before do
+      cequel.execute("CREATE TABLE posts (permalink text PRIMARY KEY)")
+    end
+
+    it 'should read name correctly' do
+      table.partition_keys.first.name.should == :permalink
+    end
+
+    it 'should read type correctly' do
+      table.partition_keys.first.type.should be_a(Cequel::Type::Text)
+    end
+
+    it 'should have no nonpartition keys' do
+      table.clustering_columns.should be_empty
+    end
+  end # describe 'reading simple key'
+
+  describe 'reading single non-partition key' do
+    before do
+      cequel.execute <<-CQL
+        CREATE TABLE posts (
+          blog_subdomain text,
+          permalink ascii,
+          PRIMARY KEY (blog_subdomain, permalink)
+        )
+      CQL
+    end
+
+    it 'should read partition key name' do
+      table.partition_keys.map(&:name).should == [:blog_subdomain]
+    end
+
+    it 'should read partition key type' do
+      table.partition_keys.map(&:type).should == [Cequel::Type::Text.instance]
+    end
+
+    it 'should read non-partition key name' do
+      table.clustering_columns.map(&:name).should == [:permalink]
+    end
+
+    it 'should read non-partition key type' do
+      table.clustering_columns.map(&:type).
+        should == [Cequel::Type::Ascii.instance]
+    end
+
+    it 'should default clustering order to asc' do
+      table.clustering_columns.map(&:clustering_order).should == [:asc]
+    end
+  end # describe 'reading single non-partition key'
+
+  describe 'reading reverse-ordered non-partition key' do
+    before do
+      cequel.execute <<-CQL
+        CREATE TABLE posts (
+          blog_subdomain text,
+          permalink ascii,
+          PRIMARY KEY (blog_subdomain, permalink)
+        )
+        WITH CLUSTERING ORDER BY (permalink DESC)
+      CQL
+    end
+
+    it 'should read non-partition key name' do
+      table.clustering_columns.map(&:name).should == [:permalink]
+    end
+
+    it 'should read non-partition key type' do
+      table.clustering_columns.map(&:type).
+        should == [Cequel::Type::Ascii.instance]
+    end
+
+    it 'should recognize reversed clustering order' do
+      table.clustering_columns.map(&:clustering_order).should == [:desc]
+    end
+  end # describe 'reading reverse-ordered non-partition key'
+
+  describe 'reading compound non-partition key' do
+    before do
+      cequel.execute <<-CQL
+        CREATE TABLE posts (
+          blog_subdomain text,
+          permalink ascii,
+          author_id uuid,
+          PRIMARY KEY (blog_subdomain, permalink, author_id)
+        )
+        WITH CLUSTERING ORDER BY (permalink DESC, author_id ASC)
+      CQL
+    end
+
+    it 'should read non-partition key names' do
+      table.clustering_columns.map(&:name).should == [:permalink, :author_id]
+    end
+
+    it 'should read non-partition key types' do
+      table.clustering_columns.map(&:type).
+        should == [Cequel::Type::Ascii.instance, Cequel::Type::Uuid.instance]
+    end
+
+    it 'should read heterogeneous clustering orders' do
+      table.clustering_columns.map(&:clustering_order).should == [:desc, :asc]
+    end
+  end # describe 'reading compound non-partition key'
+
+  describe 'reading compound partition key' do
+    before do
+      cequel.execute <<-CQL
+        CREATE TABLE posts (
+          blog_subdomain text,
+          permalink ascii,
+          PRIMARY KEY ((blog_subdomain, permalink))
+        )
+      CQL
+    end
+
+    it 'should read partition key names' do
+      table.partition_keys.map(&:name).should == [:blog_subdomain, :permalink]
+    end
+
+    it 'should read partition key types' do
+      table.partition_keys.map(&:type).
+        should == [Cequel::Type::Text.instance, Cequel::Type::Ascii.instance]
+    end
+
+    it 'should have empty nonpartition keys' do
+      table.clustering_columns.should be_empty
+    end
+
+  end # describe 'reading compound partition key'
+
+  describe 'reading compound partition and non-partition keys' do
+    before do
+      cequel.execute <<-CQL
+        CREATE TABLE posts (
+          blog_subdomain text,
+          permalink ascii,
+          author_id uuid,
+          published_at timestamp,
+          PRIMARY KEY ((blog_subdomain, permalink), author_id, published_at)
+        )
+        WITH CLUSTERING ORDER BY (author_id ASC, published_at DESC)
+      CQL
+    end
+
+    it 'should read partition key names' do
+      table.partition_keys.map(&:name).should == [:blog_subdomain, :permalink]
+    end
+
+    it 'should read partition key types' do
+      table.partition_keys.map(&:type).
+        should == [Cequel::Type::Text.instance, Cequel::Type::Ascii.instance]
+    end
+
+    it 'should read non-partition key names' do
+      table.clustering_columns.map(&:name).
+        should == [:author_id, :published_at]
+    end
+
+    it 'should read non-partition key types' do
+      table.clustering_columns.map(&:type).should ==
+        [Cequel::Type::Uuid.instance, Cequel::Type::Timestamp.instance]
+    end
+
+    it 'should read clustering order' do
+      table.clustering_columns.map(&:clustering_order).should == [:asc, :desc]
+    end
+
+  end # describe 'reading compound partition and non-partition keys'
+
+  describe 'reading data columns' do
+
+    before do
+      cequel.execute <<-CQL
+        CREATE TABLE posts (
+          blog_subdomain text,
+          permalink ascii,
+          title text,
+          author_id uuid,
+          categories LIST <text>,
+          tags SET <text>,
+          trackbacks MAP <timestamp,ascii>,
+          PRIMARY KEY (blog_subdomain, permalink)
+        )
+      CQL
+      cequel.execute('CREATE INDEX ON posts (author_id)')
+    end
+
+    it 'should read types of scalar data columns' do
+      table.data_columns.find { |column| column.name == :title }.type.
+        should == Cequel::Type[:text]
+      table.data_columns.find { |column| column.name == :author_id }.type.
+        should == Cequel::Type[:uuid]
+    end
+
+    it 'should read index attributes' do
+      table.data_columns.find { |column| column.name == :author_id }.index_name.
+        should == :posts_author_id_idx
+    end
+
+    it 'should leave nil index for non-indexed columns' do
+      table.data_columns.find { |column| column.name == :title }.index_name.
+        should be_nil
+    end
+
+    it 'should read list columns' do
+      table.data_columns.find { |column| column.name == :categories }.
+        should be_a(Cequel::Schema::List)
+    end
+
+    it 'should read list column type' do
+      table.data_columns.find { |column| column.name == :categories }.type.
+        should == Cequel::Type[:text]
+    end
+
+    it 'should read set columns' do
+      table.data_columns.find { |column| column.name == :tags }.
+        should be_a(Cequel::Schema::Set)
+    end
+
+    it 'should read set column type' do
+      table.data_columns.find { |column| column.name == :tags }.type.
+        should == Cequel::Type[:text]
+    end
+
+    it 'should read map columns' do
+      table.data_columns.find { |column| column.name == :trackbacks }.
+        should be_a(Cequel::Schema::Map)
+    end
+
+    it 'should read map column key type' do
+      table.data_columns.find { |column| column.name == :trackbacks }.key_type.
+        should == Cequel::Type[:timestamp]
+    end
+
+    it 'should read map column value type' do
+      table.data_columns.find { |column| column.name == :trackbacks }.
+        value_type.should == Cequel::Type[:ascii]
+    end
+
+  end # describe 'reading data columns'
+
+  describe 'reading storage properties' do
+
+    before do
+      cequel.execute <<-CQL
+        CREATE TABLE posts (permalink text PRIMARY KEY)
+        WITH bloom_filter_fp_chance = 0.02
+        AND comment = 'Posts table'
+        AND compaction = {
+          'class' : 'SizeTieredCompactionStrategy',
+          'bucket_high' : 1.8,
+          'max_threshold' : 64,
+          'min_sstable_size' : 50,
+          'tombstone_compaction_interval' : 2
+        } AND compression = {
+          'sstable_compression' : 'DeflateCompressor',
+          'chunk_length_kb' : 128,
+          'crc_check_chance' : 0.5
+        }
+      CQL
+    end
+
+    it 'should read float properties' do
+      table.property(:bloom_filter_fp_chance).should == 0.02
+    end
+
+    it 'should read string properties' do
+      table.property(:comment).should == 'Posts table'
+    end
+
+    it 'should read and simplify compaction class' do
+      table.property(:compaction)[:class].
+        should == 'SizeTieredCompactionStrategy'
+    end
+
+    it 'should read float properties from compaction hash' do
+      table.property(:compaction)[:bucket_high].should == 1.8
+    end
+
+    it 'should read integer properties from compaction hash' do
+      table.property(:compaction)[:max_threshold].should == 64
+    end
+
+    it 'should read and simplify compression class' do
+      table.property(:compression)[:sstable_compression].
+        should == 'DeflateCompressor'
+    end
+
+    it 'should read integer properties from compression class' do
+      table.property(:compression)[:chunk_length_kb].should == 128
+    end
+
+    it 'should read float properties from compression class' do
+      table.property(:compression)[:crc_check_chance].should == 0.5
+    end
+
+  end # describe 'reading storage properties'
+
+  describe 'compact storage' do
+
+    it 'should read non-compact storage status' do
+      cequel.execute <<-CQL
+        CREATE TABLE posts (permalink text PRIMARY KEY, body text)
+      CQL
+      table.should_not be_compact_storage
+    end
+
+    it 'should read compact storage status' do
+      cequel.execute <<-CQL
+        CREATE TABLE posts (permalink text PRIMARY KEY, body text)
+        WITH COMPACT STORAGE
+      CQL
+      table.should be_compact_storage
+    end
+
+  end
+
+end