believer 0.2.14 → 0.2.15

data/lib/believer/base.rb

@@ -23,7 +23,6 @@ module Believer
     attr_accessor :id
 
     def initialize(attrs = {})
-      @attributes = {}
       set_attributes(attrs)
       yield self if block_given?
     end
@@ -47,6 +46,7 @@ module Believer
     end
 
     def set_attributes(attrs)
+      @attributes = {}
       attrs.each do |name, val|
         send("#{name}=".to_sym, val)
       end if attrs.present?

data/lib/believer/counter.rb

@@ -1,5 +1,6 @@
 module Believer
 
+  # The counter value
   class Counter
 
     def initialize(v = 0, initial_val = nil)
@@ -7,6 +8,11 @@ module Believer
       @initial_value = initial_val.nil? ? @value : initial_val
     end
 
+    def reconcile!
+      @initial_value = @value
+      self
+    end
+
     def reset!
       @value = 0
       self

data/lib/believer/counting.rb

@@ -1,23 +1,29 @@
 module Believer
+  # Model functionality for counter columns
   module Counting
     extend ::ActiveSupport::Concern
 
     module ClassMethods
 
+      # Returns all the counter columns
+      # @return an array of Column
       def counter_columns
         columns_with_type(:counter)
       end
 
+      # Is this a model class with counter columns?
       def is_counter_table?
         counter_columns.any?
       end
 
     end
 
+    # Is this a model with counters?
     def is_counter_instance?
       self.class.is_counter_table?
     end
 
+    # Returns true if there are any counter increments or decrements
     def has_counter_diffs?
       self.class.counter_columns.any? do |col|
         counter = self.send(col.name)
@@ -25,5 +31,31 @@ module Believer
       end
     end
 
+    # Reloads from DB, resets all counters and saves, which effectively resets all counters
+    def reset_counters!
+      reload!
+      self.class.counter_columns.each do |cc|
+        counter = self.send(cc.name)
+        counter.reset! unless counter.nil?
+      end
+      save
+    end
+
+    # Increments a counter and saves the receiver model
+    def incr_counter!(name, val = 1)
+      counter = self.send(name.to_sym)
+      counter.incr(val)
+      save
+      counter.reconcile!
+    end
+
+    # Increments a counter and saves the receiver model
+    def decr_counter!(name, decr = 1)
+      counter = self.send(name.to_sym)
+      counter.decr(val)
+      save
+      counter.reconcile!
+    end
+
   end
 end

data/lib/believer/environment/base_env.rb

@@ -10,6 +10,11 @@ module Believer
               :logger => {
                   :use_environment => true,
                   :level => ::Logger::DEBUG
+              },
+              :test => {
+                  :life_cycle => {
+                      :counters => :destroy
+                  }
               }
           }
       }

data/lib/believer/test/database.rb

@@ -14,7 +14,7 @@ module Believer
         keyspace = ::Believer::KeySpace.new(env)
         # First delete the existing keyspace
         begin
-          puts "Dropping keyspace"
+          #env.logger.debug "Dropping keyspace"
           keyspace.drop
         rescue Cql::QueryError
         end
@@ -30,7 +30,7 @@ module Believer
             clazz = cl
           end
           if clazz.ancestors.include?(Believer::Base)
-            puts "Creating table #{clazz.table_name}"
+            #puts "Creating table #{clazz.table_name}"
             clazz.create_table()
           end
 

data/lib/believer/test/test_run_life_cycle.rb

@@ -5,7 +5,7 @@ module Believer
       extend ActiveSupport::Concern
 
       included do
-        #Believer::Base.observers = Destructor
+
         Believer::Base.after_save do |model|
           Destructor.instance.after_save(model)
         end
@@ -16,21 +16,44 @@ module Believer
       end
 
       # Detroys all CqlRecord::Base instances created
-      class Destructor# < Believer::Observer
+      class Destructor
         include Singleton
-#        observe Believer::Base
+
+        def counters_action
+          if @counters_action.nil?
+            begin
+              @counters_action = Believer::Base.environment.believer_configuration[:test][:life_cycle][:counters].to_sym
+            rescue
+              @counters_action = :destroy
+            end
+          end
+          @counters_action
+        end
+
+        def should_destroy?(model)
+          #return false if model.is_counter_instance? && retain_counter_models?
+          true
+        end
 
         def cleanup
-          unless @observed_models.nil? || @observed_models.empty?
-            @observed_models.each do |model|
-              begin
-                model.destroy
-              rescue Exception => e
-                puts "Could not destroy model #{model}: #{e}\n#{e.backtrace.join("\n")}"
+          @observed_models.each do |model|
+            begin
+              if model.is_counter_instance?
+                case counters_action
+                  when :destroy
+                    model.destroy if should_destroy?(model)
+                  when :reset
+                    model.reset_counters!
+                  when :retain
+                end
+              else
+                model.destroy if should_destroy?(model)
               end
+            rescue Exception => e
+              puts "Could not destroy model #{model}: #{e}\n#{e.backtrace.join("\n")}"
             end
-            @observed_models = nil
-          end
+          end unless @observed_models.nil? || @observed_models.empty?
+          @observed_models = nil
         end
 
         def observed_models

data/lib/believer/version.rb

@@ -1,5 +1,5 @@
 module Believer
   module Version
-    VERSION = '0.2.14'
+    VERSION = '0.2.15'
   end
 end

data/spec/believer/columns_spec.rb

@@ -14,8 +14,10 @@ describe Believer::Columns do
     string_cols = Test::Song.columns_with_type(:string)
     expect(string_cols.size).to eql 4
 
-    counter_cols = Test::AlbumSales.columns_with_type(:counter)
-    expect(counter_cols).to eql [Test::AlbumSales.columns[:sales]]
+    counter_cols = Test::AlbumStatistics.columns_with_type(:counter)
+    expect(counter_cols.size).to eql 2
+    expect(counter_cols).to include Test::AlbumStatistics.columns[:sold]
+    expect(counter_cols).to include Test::AlbumStatistics.columns[:produced]
   end
 
 end

data/spec/believer/counting_spec.rb

@@ -4,58 +4,72 @@ 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
+    expect(Test::AlbumStatistics.is_counter_table?).to eql true
   end
 
   it 'should detect a changed counter instance' do
-    album_sales = Test::AlbumSales.new
+    album_sales = Test::AlbumStatistics.new
     expect(album_sales.has_counter_diffs?).to eql false
-    album_sales.sales.incr
+    album_sales.sold.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
+    album_sales = Test::AlbumStatistics.new
+    album_sales.sold = 2
+    expect(album_sales.sold.to_i).to eql 2
   end
 
   it 'should be able to undo changes in a counter' do
-    album_sales = Test::AlbumSales.new
-    album_sales.sales.incr
+    album_sales = Test::AlbumStatistics.new
+    album_sales.sold.incr
     expect(album_sales.has_counter_diffs?).to eql true
-    album_sales.sales.undo_changes!
+    album_sales.sold.undo_changes!
     expect(album_sales.has_counter_diffs?).to eql false
   end
 
   it 'should be able to reset a counter' do
     album_attrs = {:artist_name => 'CSNY', :name => 'Deja vu'}
-    album_sales = Test::AlbumSales.new(album_attrs)
-    album_sales.sales.incr(4)
-    expect(album_sales.has_counter_diffs?).to eql true
+    album_sales = Test::AlbumStatistics.new(album_attrs)
+    album_sales.incr_counter!(:sold, 4)
+
+    album_sales = Test::AlbumStatistics.where(album_attrs).first
+    expect(album_sales.sold.value).to eql 4
+    album_sales.sold.reset!
     album_sales.save
 
-    album_sales = Test::AlbumSales.where(album_attrs).first
-    expect(album_sales.sales.value).to eql 4
-    album_sales.sales.reset!
+    album_sales = Test::AlbumStatistics.where(album_attrs).first
+    expect(album_sales.sold.value).to eql 0
+  end
+
+  it 'should be able to reset all counters in one go' do
+    album_attrs = {:artist_name => 'CSNY', :name => 'Deja vu'}
+    album_sales = Test::AlbumStatistics.new(album_attrs)
+    album_sales.sold.incr(4)
+    album_sales.produced.incr(7)
+    expect(album_sales.has_counter_diffs?).to eql true
     album_sales.save
 
-    album_sales = Test::AlbumSales.where(album_attrs).first
-    expect(album_sales.sales.value).to eql 0
+    album_sales = Test::AlbumStatistics.where(album_attrs).first
+    expect(album_sales.sold.value).to eql 4
+    expect(album_sales.produced.value).to eql 7
+    album_sales.reset_counters!
+
+    album_sales = Test::AlbumStatistics.where(album_attrs).first
+    expect(album_sales.sold.value).to eql 0
+    expect(album_sales.produced.value).to eql 0
   end
 
   it 'should be able to persist a counter value' do
-    album_sales = Test::AlbumSales.new(:artist_name => 'CSNY', :name => 'Deja vu')
-    album_sales.sales.incr
-    album_sales.save
-    expect(album_sales.sales.value).to eql 1
+    album_sales = Test::AlbumStatistics.new(:artist_name => 'CSNY', :name => 'Deja vu')
+    album_sales.incr_counter!(:sold)
+    expect(album_sales.sold.value).to eql 1
 
-    album_sales = Test::AlbumSales.where(:artist_name => 'CSNY', :name => 'Deja vu').first
-    album_sales.sales.incr
-    album_sales.save
+    album_sales = Test::AlbumStatistics.where(:artist_name => 'CSNY', :name => 'Deja vu').first
+    album_sales.incr_counter!(:sold)
 
-    album_sales = Test::AlbumSales.where(:artist_name => 'CSNY', :name => 'Deja vu').first
-    expect(album_sales.sales.value).to eql 2
+    album_sales = Test::AlbumStatistics.where(:artist_name => 'CSNY', :name => 'Deja vu').first
+    expect(album_sales.sold.value).to eql 2
   end
 
 end

data/spec/believer/update_spec.rb

@@ -6,8 +6,8 @@ describe Believer::Update do
     Test::Artist.create(:name => 'Beatles', :label => 'Apple')
   end
 
-  let :album_sales do
-    Test::AlbumSales.create(:artist_name => 'Beatles', :name => 'Revolver')
+  let :album_statistics do
+    Test::AlbumStatistics.create(:artist_name => 'Beatles', :name => 'Revolver')
   end
 
   it "should create statement based on hash" do
@@ -21,37 +21,36 @@ describe Believer::Update do
   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}'"
+    album_statistics.sold.incr(2)
+    update = Believer::Update.create(album_statistics)
+    expect(update.to_cql).to eql "UPDATE album_statistics SET sold = sold + 2 WHERE artist_name = '#{album_statistics.artist_name}' AND name = '#{album_statistics.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}'"
+    album_statistics.sold.decr(2)
+    update = Believer::Update.create(album_statistics)
+    expect(update.to_cql).to eql "UPDATE album_statistics SET sold = sold - 2 WHERE artist_name = '#{album_statistics.artist_name}' AND name = '#{album_statistics.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)
+    cur_val = album_statistics.sold.to_i
+    album_statistics.sold.incr(2)
+    update = Believer::Update.create(album_statistics)
     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)
+    cur_album_statistics = Test::AlbumStatistics.where(album_statistics.key_values).first
+    expect(cur_album_statistics.sold.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)
+    cur_val = album_statistics.reload!.sold.to_i
+    album_statistics.sold.incr(2)
+    album_statistics.sold.decr(2)
+    expect(album_statistics.sold.to_i).to eql cur_val
+    update = Believer::Update.create(album_statistics)
     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
+    cur_album_statistics = Test::AlbumStatistics.where(album_statistics.key_values).first
+    expect(cur_album_statistics.sold.to_i).to eql cur_val
   end
 
   it "should update the values" do

data/spec/support/test_classes.rb

@@ -34,11 +34,12 @@ module Test
     has_single :album, :class => 'Test::Album', :key => [:artist_name, :album_name], :foreign_key => [:artist_name, :name]
   end
 
-  class AlbumSales < Believer::Base
+  class AlbumStatistics < Believer::Base
     column :artist_name
     column :name
 
-    column :sales, :type => :counter
+    column :sold, :type => :counter
+    column :produced, :type => :counter
 
     primary_key :artist_name, :name
   end
@@ -93,7 +94,7 @@ module Test
   end
 
   Believer::Base.environment = test_environment
-  CLASSES = [Artist, Album, Song, AlbumSales, Event, Person, Child]
+  CLASSES = [Artist, Album, Song, AlbumStatistics, Event, Person, Child]
   #CLASSES.each {|cl| cl.environment = test_environment}
 
   def self.classes

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: believer
 version: !ruby/object:Gem::Version
-  version: 0.2.14
+  version: 0.2.15
   prerelease: 
 platform: ruby
 authors: