believer 0.2.5 → 0.2.6

data/spec/believer/counting_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Believer::Counting do
+
+  it 'should detect a counter table' do
+    expect(Test::Artist.is_counter_table?).to eql false
+    expect(Test::AlbumSales.is_counter_table?).to eql true
+  end
+
+  it 'should detect a changed counter instance' do
+    album_sales = Test::AlbumSales.new
+    expect(album_sales.has_counter_diffs?).to eql false
+    album_sales.sales.incr
+    expect(album_sales.has_counter_diffs?).to eql true
+  end
+
+  it 'should be able to set a counter using a number' do
+    album_sales = Test::AlbumSales.new
+    album_sales.sales = 2
+    expect(album_sales.sales.to_i).to eql 2
+  end
+
+  it 'should be able to reset a counter' do
+    album_sales = Test::AlbumSales.new
+    album_sales.sales.incr
+    expect(album_sales.has_counter_diffs?).to eql true
+    album_sales.sales.reset!
+    expect(album_sales.has_counter_diffs?).to eql false
+  end
+
+end

data/spec/believer/delete_spec.rb

@@ -5,7 +5,7 @@ describe Believer::Delete do
   it "create a valid delete statement" do
     del = Believer::Delete.new(:record_class => Test::Artist)
     del = del.where(:id => 1)
-    del.to_cql.should == 'DELETE FROM artists WHERE id = 1'
+    expect(del.to_cql).to eql 'DELETE FROM artists WHERE id = 1'
   end
 
 

data/spec/believer/environment_spec.rb

@@ -17,8 +17,8 @@ describe Believer::Environment do
     end
     Rails = Struct.new(:root, :env, :logger).new(File.join(RSpec.configuration.test_files_dir, 'rails'), :test, nil)
     env = Believer::Base.environment
-    env.class.should == Believer::Environment::RailsEnv
-    env.configuration[:host].should == '123.456.789.0'
+    expect(env.class).to eql Believer::Environment::RailsEnv
+    expect(env.configuration[:host]).to eql '123.456.789.0'
     Object.instance_eval { remove_const :Rails}
   end
 
@@ -28,8 +28,8 @@ describe Believer::Environment do
     end
     Merb = Struct.new(:root, :environment, :logger).new(File.join(RSpec.configuration.test_files_dir, 'merb'), :test, nil)
     env = Believer::Base.environment
-    env.class.should == Believer::Environment::MerbEnv
-    env.configuration[:host].should == 'merb.test.local'
+    expect(env.class).to eql Believer::Environment::MerbEnv
+    expect(env.configuration[:host]).to eql 'merb.test.local'
     Object.instance_eval { remove_const :Merb}
   end
 

data/spec/believer/finder_methods_spec.rb

@@ -11,29 +11,29 @@ describe Believer::FinderMethods do
 
   it 'exists? should return true for an existing object' do
     # Test all variants
-    Test::Artist.exists?(:name => 'U2').should == true
-    Test::Artist.exists?('name = ?', 'U2').should == true
+    expect(Test::Artist.exists?(:name => 'U2')).to eql true
+    expect(Test::Artist.exists?('name = ?', 'U2')).to eql true
   end
 
   it 'exists? should return false for an non-existing object' do
     # Test all variants
-    Test::Artist.exists?(:name => 'Genesis').should == false
-    Test::Artist.exists?('name = ?', 'Genesis').should == false
+    expect(Test::Artist.exists?(:name => 'Genesis')).to eql false
+    expect(Test::Artist.exists?('name = ?', 'Genesis')).to eql false
   end
 
   it 'find using a hash' do
-    Test::Artist.find(:name => 'U2').should == @u2
+    expect(Test::Artist.find(:name => 'U2')).to eql @u2
   end
 
   it 'find using an array' do
     res = Test::Artist.find('U2', 'UB 40')
-    res.size.should == 2
-    res.include?(@u2).should == true
-    res.include?(@ub_40).should == true
+    expect(res.size).to eql 2
+    expect(res.include?(@u2)).to eql true
+    expect(res.include?(@ub_40)).to eql true
   end
 
   it 'find using single primary key value' do
-    Test::Artist.find('U2').should == @u2
+    expect(Test::Artist.find('U2')).to eql @u2
   end
 
 end

data/spec/believer/insert_spec.rb

@@ -4,6 +4,6 @@ describe Believer::Insert do
 
   it "create statement based on hash" do
     insert = Believer::Insert.new(:record_class => Test::Artist, :values => {:id => 1, :name => 'Beatles'})
-    insert.to_cql.should == "INSERT INTO artists (id, name) VALUES (1, 'Beatles')"
+    expect(insert.to_cql).to eql "INSERT INTO artists (id, name) VALUES (1, 'Beatles')"
   end
 end

data/spec/believer/limit_spec.rb

@@ -2,6 +2,6 @@ require 'spec_helper'
 
 describe Believer::Limit do
   it 'create CQL' do
-    Believer::Limit.new(23).to_cql.downcase.should == 'limit 23'
+    expect(Believer::Limit.new(23).to_cql.downcase).to eql 'limit 23'
   end
 end

data/spec/believer/order_by_spec.rb

@@ -4,11 +4,11 @@ describe Believer::OrderBy do
 
   it "create a CQL expression" do
     ob = Believer::OrderBy.new(:field)
-    ob.to_cql.downcase.should == 'order by field asc'
+    expect(ob.to_cql.downcase).to eql 'order by field asc'
   end
 
   it "reverse order" do
     ob = Believer::OrderBy.new(:field).inverse
-    ob.to_cql.downcase.should == 'order by field desc'
+    expect(ob.to_cql.downcase).to eql 'order by field desc'
   end
 end

data/spec/believer/query_spec.rb

@@ -32,7 +32,7 @@ describe Believer::Query do
         where(:release_date => Time.utc(2013)).
         order(:name, :desc).
         limit(10)
-    q.to_cql.should == "SELECT name, artist FROM albums WHERE name = 'Revolver' AND release_date = '2013-01-01 00:00:00+0000' ORDER BY name DESC LIMIT 10"
+    expect(q.to_cql).to eql "SELECT name, artist FROM albums WHERE name = 'Revolver' AND release_date = '2013-01-01 00:00:00+0000' ORDER BY name DESC LIMIT 10"
   end
 
   it 'should include allow filtering clause' do
@@ -48,7 +48,7 @@ describe Believer::Query do
   it 'should behave like an Enumerable' do
     q = Believer::Query.new(:record_class => Test::Artist).where(:name => artists.map { |o| o.name })
     Enumerable.instance_methods(false).each do |enum_method|
-      q.respond_to?(enum_method.to_sym).should == true
+      expect(q.respond_to?(enum_method.to_sym)).to eql true
     end
   end
 

data/spec/believer/querying_spec.rb

@@ -9,7 +9,7 @@ describe Believer::Querying do
       {:method => :limit, :args => 10},
   ].each do |scenario|
     it "#{scenario[:method]} call should return a query object" do
-      Test::Artist.send(scenario[:method], scenario[:args]).class.should == Believer::Query
+      expect(Test::Artist.send(scenario[:method], scenario[:args]).class).to eql Believer::Query
     end
   end
 

data/spec/believer/relation_spec.rb

@@ -21,28 +21,28 @@ describe Believer::Relation do
 
   it "report correct size of one to many relation" do
     a = Test::Artist.where(:name => 'Beatles').first
-    a.albums.size.should == 3
+    expect(a.albums.size).to eql 3
   end
 
   it "one to many relation collection should support exists? method" do
     a = Test::Artist.where(:name => 'Beatles').first
-    a.albums.exists?(:name => 'Help').should == true
+    expect(a.albums.exists?(:name => 'Help')).to eql true
   end
 
   it "one to many relation collection should support clear method" do
     a = Test::Artist.where(:name => 'Beatles').first
-    a.albums.size.should == 3
+    expect(a.albums.size).to eql 3
     a.albums.clear
-    a.albums.size.should == 0
+    expect(a.albums.size).to eql 0
   end
 
   it "one to many relation collection should support find method" do
     a = Test::Artist.where(:name => 'Beatles').first
-    a.albums.find(:name => 'Help').should == @help
+    expect(a.albums.find(:name => 'Help')).to eql @help
   end
 
   it "one to one relation" do
-    @have_a_cigar.album.should == Test::Album.where(:artist_name => 'Pink Floyd', :name => 'Wish you were here').first
+    expect(@have_a_cigar.album).to eql Test::Album.where(:artist_name => 'Pink Floyd', :name => 'Wish you were here').first
   end
 
 end

data/spec/believer/test_run_life_cycle_spec.rb

@@ -22,7 +22,7 @@ describe Believer::Test::TestRunLifeCycle do
 
   after :all do
     Fly.drop_table
-    @monitor.kill_count.should == @created.size
+    expect(@monitor.kill_count).to eql @created.size
   end
 
   after :each do
@@ -32,7 +32,7 @@ describe Believer::Test::TestRunLifeCycle do
   end
 
   it "should clean all created objects, even after a fail" do
-    Believer::Test::TestRunLifeCycle::Destructor.instance.observed_models.size.should == CREATE_COUNT
+    expect(Believer::Test::TestRunLifeCycle::Destructor.instance.observed_models.size).to eql CREATE_COUNT
   end
 
   class Monitor

data/spec/believer/time_series_spec.rb

@@ -6,7 +6,7 @@ describe 'Time series' do
   before :each do
     @interval = 1.minute
     @start = Time.utc(2012)
-    @count = 10
+    @count = 5
     @count.times do |i|
       attrs = {:computer_id => 'ABC', :event_type => 1, :time => @start + (@interval * i)}
       Test::Event::PARAMETER_NAMES.each do |param|
@@ -16,8 +16,28 @@ describe 'Time series' do
     end
   end
 
-  it 'load all' do
-    Test::Event.where(:computer_id => 'ABC', :event_type => 1).size.should == @count
+  it 'should load all' do
+    expect(Test::Event.where(:computer_id => 'ABC', :event_type => 1).size).to eql @count
   end
 
+  it 'should load after specific time' do
+    events = Test::Event.where(:computer_id => 'ABC', :event_type => 1).where('time >= ?', @start + @interval)
+    expect(events.size).to eql(@count - 1)
+  end
+
+  it 'should load between to date' do
+    events = Test::Event.where(:computer_id => 'ABC', :event_type => 1).
+        where('time >= ?', @start + @interval).
+        where('time <= ?', @start + (@count-2) * @interval)
+    expect(events.size).to eql(@count - 2)
+  end
+
+  #it 'should load between to date' do
+  #  events = Test::Event.where(:computer_id => 'ABC', :event_type => 1).select(:computer_id, :event_type).
+  #      where('time >= ?', @start + @interval).
+  #      where('time >= ?', @start + @interval*2).
+  #      where('time <= ?', @start + (@count-2) * @interval)
+  #  expect(events.size).to eql(@count - 2)
+  #end
+
 end

data/spec/believer/update_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Believer::Update do
+
+  let :artist do
+    Test::Artist.create(:name => 'Beatles', :label => 'Apple')
+  end
+
+  let :album_sales do
+    Test::AlbumSales.create(:artist_name => 'Beatles', :name => 'Revolver')
+  end
+
+  it "should create statement based on hash" do
+    update = Believer::Update.new(:record_class => artist.class, :values => {:label => 'Apple'}).where(:name => artist.name)
+    expect(update.to_cql).to eql "UPDATE artists SET label = '#{artist.label}' WHERE name = '#{artist.name}'"
+  end
+
+  it "should create statement based on an object" do
+    update = Believer::Update.create(artist)
+    expect(update.to_cql).to eql "UPDATE artists SET label = '#{artist.label}' WHERE name = '#{artist.name}'"
+  end
+
+  it "should create create a correct statement for a counter increment" do
+    album_sales.sales.incr(2)
+    update = Believer::Update.create(album_sales)
+    expect(update.to_cql).to eql "UPDATE album_sales SET sales = sales + 2 WHERE artist_name = '#{album_sales.artist_name}' AND name = '#{album_sales.name}'"
+  end
+
+  it "should create create a correct statement for a counter decrement" do
+    album_sales.sales.decr(2)
+    update = Believer::Update.create(album_sales)
+    expect(update.to_cql).to eql "UPDATE album_sales SET sales = sales - 2 WHERE artist_name = '#{album_sales.artist_name}' AND name = '#{album_sales.name}'"
+  end
+
+  it "should execute a counter change" do
+    cur_val = album_sales.sales.to_i
+    album_sales.sales.incr(2)
+    update = Believer::Update.create(album_sales)
+    update.execute
+    cur_album_sales = Test::AlbumSales.where(album_sales.key_values).first
+    expect(cur_album_sales.sales.to_i).to eql (cur_val + 2)
+  end
+
+  it "should not execute if no changes are detected in any counter" do
+    cur_val = album_sales.reload!.sales.to_i
+    puts "Cur val: #{cur_val}"
+    album_sales.sales.incr(2)
+    album_sales.sales.decr(2)
+    expect(album_sales.sales.to_i).to eql cur_val
+    update = Believer::Update.create(album_sales)
+    expect(update.execute).to eql false
+
+    cur_album_sales = Test::AlbumSales.where(album_sales.key_values).first
+    expect(cur_album_sales.sales.to_i).to eql cur_val
+  end
+
+  it "should update the values" do
+    artist.label = 'Chrysalis'
+    Believer::Update.create(artist).execute
+    loaded_artist = Test::Artist.where(:name => 'Beatles').first
+    expect(loaded_artist.label).to eql('Chrysalis')
+  end
+
+  it "should update the values" do
+    artist.label = 'Chrysalis'
+    Believer::Update.create(artist).execute
+    loaded_artist = Test::Artist.where(:name => 'Beatles').first
+    expect(loaded_artist.label).to eql('Chrysalis')
+  end
+
+end

data/spec/believer/where_spec.rb

@@ -9,20 +9,20 @@ describe Believer::WhereClause do
       [:timestamp, Time.utc(2013), "field = '2013-01-01 00:00:00+0000'"],
   ].each do |scenario|
     it "simple #{scenario[0]} parameter " do
-      Believer::WhereClause.new('field = ?', scenario[1]).to_cql.downcase.should == scenario[2]
+      expect(Believer::WhereClause.new('field = ?', scenario[1]).to_cql.downcase).to eql scenario[2]
     end
   end
 
   it 'multiple parameters' do
-    Believer::WhereClause.new('a = ? AND b = ? AND c = ?', 1, 2, 3).to_cql.downcase.should == 'a = 1 and b = 2 and c = 3'
+    expect(Believer::WhereClause.new('a = ? AND b = ? AND c = ?', 1, 2, 3).to_cql.downcase).to eql 'a = 1 and b = 2 and c = 3'
   end
 
   it 'simple hash parameter' do
-    Believer::WhereClause.new(:a => 1, :b => 2).to_cql.downcase.should == 'a = 1 and b = 2'
+    expect(Believer::WhereClause.new(:a => 1, :b => 2).to_cql.downcase).to eql 'a = 1 and b = 2'
   end
 
   it 'enumerable hash parameter' do
-    Believer::WhereClause.new(:a => [1, 2, 3]).to_cql.downcase.should == 'a in (1,2,3)'
+    expect(Believer::WhereClause.new(:a => [1, 2, 3]).to_cql.downcase).to eql 'a in (1,2,3)'
   end
 
 end

data/spec/spec_helper.rb

@@ -16,8 +16,12 @@ Dir[File.expand_path('../support/*.rb', __FILE__)].each {|f| require f}
 
 setup_database
 
-RSpec.configure do |c|
-  c.add_setting :test_files_dir, :default => File.expand_path('../test_files/', __FILE__)
+RSpec.configure do |config|
+  config.add_setting :test_files_dir, :default => File.expand_path('../test_files/', __FILE__)
+  config.expect_with :rspec do |c|
+    # Enable only the `expect` sytax...
+    c.syntax = :expect
+  end
 end
 
 File.expand_path('../test_files/', __FILE__)

data/spec/support/setup_database.rb

@@ -5,16 +5,16 @@ def setup_database
 
   connection = env.create_connection(:connect_to_keyspace => false)
   begin
-    connection.use(env.connection_configuration[:keyspace])
+    puts "Dropping keyspace"
+    env.drop_keyspace
   rescue Cql::QueryError
+  end
+  env.create_keyspace({}, connection)
+  connection.use(env.connection_configuration[:keyspace])
 
-    env.create_keyspace({}, connection)
-    connection.use(env.connection_configuration[:keyspace])
-
-    Test.classes.each do |cl|
-      puts "Creating table #{cl.table_name}"
-      cl.create_table
-    end
+  Test.classes.each do |cl|
+    puts "Creating table #{cl.table_name}"
+    cl.create_table
   end
 
 end

data/spec/support/test_classes.rb

@@ -34,6 +34,15 @@ module Test
     has_single :album, :class => 'Test::Album', :key => [:artist_name, :album_name], :foreign_key => [:artist_name, :name]
   end
 
+  class AlbumSales < Believer::Base
+    column :artist_name
+    column :name
+
+    column :sales, :type => :counter
+
+    primary_key :artist_name, :name
+  end
+
   class Person < Believer::Base
     self.table_name= 'people'
 
@@ -41,16 +50,15 @@ module Test
     column :name, :type => :string
 
     primary_key :id
-
   end
 
   class Event < Believer::Base
     column :computer_id, :type => :string
     column :event_type, :type => :integer
-    column :time, :type => :integer, :key => true
+    column :time, :type => :timestamp, :key => true
     column :description, :type => :string
 
-    PARAMETER_NAMES = (1..50).map { |index| "parameter_#{index}".to_sym }
+    PARAMETER_NAMES = (1..5).map { |index| "parameter_#{index}".to_sym }
     PARAMETER_NAMES.each do |param|
       column param, :type => :float
     end
@@ -59,13 +67,22 @@ module Test
 
   end
 
+  class Child < Believer::Base
+    column :name, :type => :string
+    column :marbles, :type => :set, :element_type => :symbol
+    column :soccer_cards, :type => :array, :element_type => :string
+    column :family, :type => :hash, :key_type => :symbol, :value_type => :string
+
+    primary_key :name
+  end
+
   class Environment < Believer::Environment::BaseEnv
     def configuration
       {
           :host => '127.0.0.1',
           :keyspace => 'believer_test_space',
           :believer => {
-              :logger => {:level => ::Logger::INFO}
+              :logger => {:level => ::Logger::DEBUG}
           }
       }
     end
@@ -76,7 +93,7 @@ module Test
   end
 
   Believer::Base.environment = test_environment
-  CLASSES = [Artist, Album, Song, Event, Person]
+  CLASSES = [Artist, Album, Song, AlbumSales, Event, Person, Child]
   #CLASSES.each {|cl| cl.environment = test_environment}
 
   def self.classes