omega-tariffs-base 0.1.5

data/spec/lib/init.rb

@@ -0,0 +1,5 @@
+require 'spec'
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'omega-tariffs-base'))
+
+include UniqSysOmega::Tariffs

data/spec/lib/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'mocha'
+require 'timecop'
+require File.expand_path(File.join(File.dirname(__FILE__), 'active_record_classes_stub'))
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end
+
+DOESNT_MATTER = nil

data/spec/packet_filter_spec.rb

@@ -0,0 +1,287 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'lib', 'init'))
+
+describe "PacketFilterRepository" do
+  before do
+    PacketFilterRepository.reset
+    @now = Time.now
+  end
+
+  it "should return nothing for non-existent regions" do
+    # yet unregistered region ...
+    PacketFilterRepository.region_registered?(1, 2).should == false
+    PacketFilterRepository.region_paid?(1, 2).should == false
+  end
+
+  it "should register regions" do
+    # register region
+    PacketFilterRepository.register_region(1, 2, @now, 3600)
+
+    # registered but not yet paid region ...
+    PacketFilterRepository.region_registered?(1, 2).should == true
+    PacketFilterRepository.region_paid?(1, 2).should == false
+  end
+
+  it "should register and commit payments" do
+    # register region
+    PacketFilterRepository.register_region(1, 2, @now, 3600)
+
+    # pay for the region ...
+    PacketFilterRepository.pay_region(1, 2)
+
+    # registered and paid region ...
+    PacketFilterRepository.region_registered?(1, 2).should == true
+    PacketFilterRepository.region_paid?(1, 2).should == true
+  end
+
+  it "should return false for other regions when current is paid" do
+    # register region
+    PacketFilterRepository.register_region(1, 2, @now, 3600)
+
+    # pay for the region ...
+    PacketFilterRepository.pay_region(1, 2)
+
+    # this is not the region ...
+    PacketFilterRepository.region_registered?(1, 2, @now-1).should == false
+    PacketFilterRepository.region_paid?(1, 2, @now-1).should == false
+
+    # this is still the region ...
+    PacketFilterRepository.region_registered?(1, 2, @now+1).should == true
+    PacketFilterRepository.region_paid?(1, 2, @now+1).should == true
+  end
+  
+  it "should report spanning regions" do
+    # register region
+    PacketFilterRepository.register_region(1, 2, @now, 3600)
+
+    # check spanning
+    PacketFilterRepository.region_spans?(1, 2, @now, 1000).should == false
+    PacketFilterRepository.region_spans?(1, 2, @now, 3599).should == false
+    PacketFilterRepository.region_spans?(1, 2, @now, 3600).should == true
+    PacketFilterRepository.region_spans?(1, 2, @now, 5000).should == true
+  end
+  
+  it "should not end by default" do
+    PacketFilterRepository.should_end?(1, 2).should == false    
+  end
+
+  it "should_end call should return true" do
+    PacketFilterRepository.set_should_end(1, 2, @now+60).should == true
+  end
+
+  it "should end when it's scheduled" do
+    PacketFilterRepository.set_should_end(1, 2, @now+60)
+    PacketFilterRepository.should_end?(1, 2).should == false
+    Timecop.freeze(@now + 60) { PacketFilterRepository.should_end?(1, 2).should == false }
+    Timecop.freeze(@now + 61) { PacketFilterRepository.should_end?(1, 2).should == true }
+  end
+  
+  it "should not interfere with the other users and tariffs" do
+    PacketFilterRepository.set_should_end(1, 2, @now-1)
+    PacketFilterRepository.should_end?(1, 2).should == true    
+    PacketFilterRepository.should_end?(1, 3).should == false    
+    PacketFilterRepository.should_end?(8, 2).should == false    
+  end
+end
+
+describe "PacketFilter" do
+  before do
+    @settings = stub()
+    @settings.expects(:price).returns(100)
+    @settings.expects(:length).returns(3600)
+    @filter = PacketFilter.new(@settings, 1)
+
+    FinTransaction.reset_transactions
+    PacketFilterRepository.reset
+    Login.set_login_balance(1, 0)
+  end
+
+  describe "start_permitted?" do
+    it "should permit login if I have got close to enough money" do
+      Login.set_login_balance(1, 100)
+      @filter.start_permitted?(2, 1).should == true
+    end
+
+    it "should permit login if I have got enough money" do
+      Login.set_login_balance(1, 101)
+      @filter.start_permitted?(2, 1).should == true
+    end
+
+    it "should permit login if I haven't got enough money" do
+      Login.set_login_balance(1, 99)
+      @filter.start_permitted?(2, 1).should == false
+    end
+  end
+
+  describe "permitted?" do
+    it "should permit work if I have got close to enough money" do
+      Login.set_login_balance(1, 100)
+      @filter.permitted?(2, 1).should == true
+    end
+
+    it "should permit work if I have got enough money" do
+      Login.set_login_balance(1, 101)
+      @filter.permitted?(2, 1).should == true
+    end
+
+    it "should permit work if I haven't got enough money" do
+      Login.set_login_balance(1, 99)
+      @filter.permitted?(2, 1).should == false
+    end
+  end
+  
+  def make_single_activity_processed
+    activity = Activity.new
+    activity.created_at = Time.now
+    activity.login_id = 1
+    activity.amount = 3600
+
+    ft = FinTransaction.template
+    ft.club_id, ft.author_id, ft.src_account_id, ft.dst_account_id = 1, 2, 3, 4
+
+    @filter.process_activity(activity, ft)    
+  end
+
+  describe "calculate_cost" do
+    it "should return the price of the region unless paid" do
+      @filter.calculate_cost(2, 1, Time.now, 10).should == 100
+      @filter.calculate_cost(2, 1, Time.now, 3599).should == 100
+      @filter.calculate_cost(2, 1, Time.now, 3600).should == 100
+      @filter.calculate_cost(2, 1, Time.now, 3601).should == 100
+    end
+    
+    it "should return the zero price of the region if paid and Integer::MAX out of the region" do
+      Login.set_login_balance(1, 100)    
+
+      make_single_activity_processed.should == true
+
+      @filter.calculate_cost(2, 1, Time.now, 10).should == 0
+      @filter.calculate_cost(2, 1, Time.now, 3599).should == 0
+      @filter.calculate_cost(2, 1, Time.now, 3600).should == Integer::MAX
+      @filter.calculate_cost(2, 1, Time.now, 3605).should == Integer::MAX
+    end
+  end
+  
+  describe "process_activity" do
+    it "should return unsuccessful activity processing if no money" do
+      Login.set_login_balance(1, 99)
+      make_single_activity_processed.should == false
+    end    
+  end
+  
+  describe "packet life time" do
+    def actualize_balance!
+      Login.set_login_balance(1,  Login.find(1).balance - FinTransaction.transactions.sum)
+      FinTransaction.reset_transactions      
+    end
+    
+    def do_several_activities(offsets=[0])
+      ft = FinTransaction.template
+      ft.club_id, ft.author_id, ft.src_account_id, ft.dst_account_id = 1, 2, 3, 4
+      
+      offsets.each do |offset|
+        activity = Activity.new
+        activity.created_at = Time.now + offset
+        activity.login_id = 1
+        activity.amount = 30
+        @filter.process_activity(activity, ft).should == true        
+      end
+    end
+    
+    it "should allow the packet to be opened once, if there's exact amount of money on the account as needed" do
+      now = Time.now
+
+      Timecop.freeze(now) do
+        Login.set_login_balance(1, 100)    
+
+        @filter.start_permitted?(2, 1).should == true
+        @filter.permitted?(2, 1).should == true
+        
+        Login.find(1).balance.should == 100
+        do_several_activities [ 0, 30, 60 ]
+        actualize_balance!
+        Login.find(1).balance.should == 0
+      end
+
+      [ [now + 1, true, true], [now + 3598, true, true], [now + 3599, false, false], [now + 3699, false, false]].each do |variant|
+        Timecop.freeze(variant[0]) do
+          @filter.start_permitted?(2, 1).should == variant[1]
+          @filter.permitted?(2, 1).should == variant[2]
+        end
+      end
+    end
+    
+    it "should allow the packet to be opened once even if there's slightly more money on the account than needed" do
+      now = Time.now
+      
+      Timecop.freeze(now) do
+        Login.set_login_balance(1, 105)
+
+        @filter.start_permitted?(2, 1).should == true
+        @filter.permitted?(2, 1).should == true
+
+        Login.find(1).balance.should == 105
+        do_several_activities [ 0, 30, 60 ]
+        actualize_balance!
+        Login.find(1).balance.should == 5
+      end
+      
+      [ [now + 1, true, true], [now + 3598, true, true], [now + 3599, false, false], [now + 3699, false, false]].each do |variant|
+        Timecop.freeze(variant[0]) do
+          @filter.start_permitted?(2, 1).should == variant[1]
+          @filter.permitted?(2, 1).should == variant[2]
+        end
+      end
+    end
+    
+    it "should allow the packet to be opened twice if there is enough money, and the user should be charged twice" do
+      now = Time.now
+      
+      Timecop.freeze(now) do
+        Login.set_login_balance(1, 205)
+
+        @filter.start_permitted?(2, 1).should == true
+        @filter.permitted?(2, 1).should == true
+
+        Login.find(1).balance.should == 205
+        do_several_activities [ 0, 30, 60 ]
+        actualize_balance!
+        Login.find(1).balance.should == 105
+      end
+
+      # check end of the single session
+      [ [now + 1, true], [now + 3600, true], [now + 3601, false], [now + 3699, false]].each do |variant|
+        Timecop.freeze(variant[0]) do
+          @filter.permitted?(2, 1).should == variant[1]
+        end
+      end
+
+      # check if start_permitted? resets permitted? flag
+      [ [now + 1, true, true], [now + 3599, true, true], [now + 3600, true, true], [now + 3699, true, true]].each do |variant|
+        Timecop.freeze(variant[0]) do
+          @filter.start_permitted?(2, 1).should == variant[1]
+          @filter.permitted?(2, 1).should == variant[2]
+        end
+      end      
+      
+      now += 3610
+
+      Timecop.freeze(now) do
+        @filter.start_permitted?(2, 1).should == true
+        @filter.permitted?(2, 1).should == true
+
+        Login.find(1).balance.should == 105
+        do_several_activities [ 0, 30, 60 ]
+        actualize_balance!
+        Login.find(1).balance.should == 5
+      end
+
+      # check if permitted? and start_permitted? are in the correct state
+      [ [now + 1, true, true], [now + 3598, true, true], [now + 3599, false, false], [now + 3699, false, false]].each do |variant|
+        Timecop.freeze(variant[0]) do
+          @filter.start_permitted?(2, 1).should == variant[1]
+          @filter.permitted?(2, 1).should == variant[2]
+        end
+      end
+    end
+  end
+end

data/spec/rate_filter_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'lib', 'init'))
+
+describe "RateFilter" do
+  RATE = 123
+
+  before do
+    settings = mock()
+    settings.expects(:rate).returns(RATE)
+    @filter = RateFilter.new(settings, 0)
+  end
+
+  it "should permit start" do
+    @filter.start_permitted?(1, 2, 3).should == true
+  end
+
+  it "should permit going on" do
+    @filter.permitted?(1, 2, 3).should == true
+  end
+
+  it "should calculate the correct amount" do
+    @filter.calculate_cost(1, 2, 3, 3600).should == RATE
+  end
+
+  it "should process activity correctly" do
+    activity = mock()
+    activity.expects(:amount).returns(3600)
+
+    ft = FinTransaction.template
+    ft.club_id, ft.author_id, ft.src_account_id, ft.dst_account_id = 1, 2, 3, 4
+
+    FinTransaction.any_instance.expects(:volume=).with(RATE)
+    FinTransaction.any_instance.expects(:valid?).returns(true)
+
+    @filter.process_activity(activity, ft).should == true
+  end
+end

data/spec/repeating_filter_spec.rb

@@ -0,0 +1,250 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'lib', 'init'))
+
+class RepeatingMockFilter1 < Filter
+  def calculate_cost(computer_id, login_id, started_at, amount, options={})
+    Rational(amount.to_i*100, 3600)
+  end
+  
+  def process_activity(unprocessed_activity, ft, options={})
+    ft = ft.dup
+    ft.volume = Rational(unprocessed_activity.amount.to_i*100, 3600)
+    ft.save!
+    true
+  end
+end
+
+class RepeatingMockFilter2 < Filter
+  def calculate_cost(computer_id, login_id, started_at, amount, options={})
+    Rational(amount.to_i*200, 3600)
+  end
+
+  def process_activity(unprocessed_activity, ft, options={})
+    ft = ft.dup
+    ft.volume = Rational(unprocessed_activity.amount.to_i*200, 3600)
+    ft.save!
+    true
+  end
+end
+
+class RepeatingMockFilter3 < Filter
+  def calculate_cost(computer_id, login_id, started_at, amount, options={})
+    Rational(amount.to_i*300, 3600)
+  end
+
+  def process_activity(unprocessed_activity, ft, options={})
+    ft = ft.dup
+    ft.volume = Rational(unprocessed_activity.amount.to_i*300, 3600)
+    ft.save!
+    true
+  end
+end
+
+class RepeatingMockFilterWithOptionsExpectations < Filter
+end
+
+
+describe "RepeatingFilterPeriod" do
+  it "should not allow to create invalid period" do
+    lambda {
+      RepeatingFilterPeriod.new(Time.now, 300, 200, stub())
+    }.should raise_error
+  end
+  
+  it "should allow valid period creation" do
+    RepeatingFilterPeriod.new(Time.now, 300, 300, stub())
+    RepeatingFilterPeriod.new(Time.now, 123, 200, stub())
+  end
+  
+  it "should set filter value" do
+    filtah = stub()
+    RepeatingFilterPeriod.new(Time.now, 300, 300, filtah).filter.should == filtah
+  end
+  
+  it "should delegate filter value when generating ranges" do
+    filtah, now = stub(), Time.now
+    periods = RepeatingFilterPeriod.new(now, 100, 200, filtah).generate_in_range(now-1, now + 410)
+    periods.each { |p| p.filter.should == filtah }
+  end
+  
+  it "should recur correctly" do
+    test_start_time = Time.now
+    
+    period = RepeatingFilterPeriod.new(test_start_time, 2*3600, 86400, stub())
+
+    # today
+    period.includes?(test_start_time).should == true
+    period.includes?(test_start_time+123).should == true 
+    period.includes?(test_start_time+7199).should == true 
+    period.includes?(test_start_time+7200).should == false 
+    period.includes?(test_start_time+56124).should == false 
+    period.includes?(test_start_time+86399).should == false 
+
+    # tomorrow
+    period.includes?(test_start_time+86400).should == true
+    period.includes?(test_start_time+86400+123).should == true 
+    period.includes?(test_start_time+86400+7199).should == true 
+    period.includes?(test_start_time+86400+7200).should == false 
+    period.includes?(test_start_time+86400+56124).should == false 
+    period.includes?(test_start_time+86400+86399).should == false 
+  end
+  
+  it "should support === operator to behave exactly like includes?" do
+    period = RepeatingFilterPeriod.new(Time.now, 2*3600, 86400, stub())
+    period.expects(:includes?).with(1024).returns(:thats_what_include_returns)
+    (period === 1024).should == :thats_what_include_returns
+  end
+  
+  it "should generate correct ranges array" do
+    test_start_time = Time.now
+    
+    period = RepeatingFilterPeriod.new(test_start_time, 2*3600, 86400, stub())
+    
+    ranges = period.generate_in_range(test_start_time, test_start_time+86400).map { |r| r.as_range }
+    ranges.should == [ (test_start_time.to_i ... test_start_time.to_i+2*3600) ]
+
+    ranges = period.generate_in_range(test_start_time, test_start_time+45000).map { |r| r.as_range }
+    ranges.should == [ (test_start_time.to_i ... test_start_time.to_i+2*3600) ]
+
+    ranges = period.generate_in_range(test_start_time, test_start_time+2*86400).map { |r| r.as_range }
+    ranges.should == [ (test_start_time.to_i ... test_start_time.to_i+2*3600), (test_start_time.to_i+86400 ... test_start_time.to_i+86400+2*3600) ]
+
+    ranges = period.generate_in_range(test_start_time, test_start_time+1024*86400).map { |r| r.as_range }
+    ranges.size.should == 1024
+  end
+
+  it "should return correct variant of the localized period" do
+    test_start_time = Time.now
+    period = RepeatingFilterPeriod.new(test_start_time, 2*3600, 86400, stub())
+    period.local_period(test_start_time+30.days+10.seconds).as_range.should ==
+            ((test_start_time+30*86400).to_i ... (test_start_time+2*3600+30*86400).to_i)
+  end
+end
+
+describe "SortableRange" do
+  it "should sort the correct way" do
+    r_1_3 = SortableRange.new(1, 3)
+    r_5_9 = SortableRange.new(5, 9)
+    r_16_18= SortableRange.new(16, 18)
+    [ r_5_9, r_1_3, r_16_18 ].sort.should == [ r_1_3, r_5_9, r_16_18 ]
+  end
+  
+  it "should return corresponding Range object" do
+    SortableRange.new(10, 13).as_range.should == Range.new(10,13)
+  end
+  
+  it "should have filter field" do
+    r = SortableRange.new(10, 13)
+    r.filter = 123
+    r.filter.should == 123
+  end
+end
+
+describe "RepeatingFilter" do
+  before do
+    now = Time.at(0)
+    @settings = Settings.new({
+      { :starts_at => now, :length => 3600, :period => 10800 } => { :klass => "RepeatingMockFilter1", :settings => { :vasya => "pupkin" } },
+      { :starts_at => now+3600, :length => 3600, :period => 10800 } => { :klass => "RepeatingMockFilter2", :settings => { :vasya => "vanin" } },
+      { :starts_at => now+7200, :length => 3600, :period => 10800 } => { :klass => "RepeatingMockFilter3", :settings => { :vasya => "vanin" } }
+    }) 
+    @filter = RepeatingFilter.new(@settings, 0)
+  end
+  
+  it "should not instantinate when periods are not cosistent" do
+    now = Time.at(0)
+    settings = Settings.new({
+      { :starts_at => now, :length => 100, :period => 300 } => { :klass => "RepeatingMockFilter1", :settings => { :vasya => "pupkin" } },
+      { :starts_at => now+100, :length => 100, :period => 300 } => { :klass => "RepeatingMockFilter2", :settings => { :vasya => "vanin" } }
+    })
+    
+    lambda {
+      filter = RepeatingFilter.new(settings, 0)
+    }.should raise_error(Exception, /Inconsistent periods/)
+  end
+  
+  it "should not instantinate when periods are intersecting" do
+    now = Time.at(0)
+    settings = Settings.new({
+      { :starts_at => now, :length => 95, :period => 301 } => { :klass => "RepeatingMockFilter1", :settings => { :vasya => "pupkin" } },
+      { :starts_at => now+100, :length => 100, :period => 300 } => { :klass => "RepeatingMockFilter2", :settings => { :vasya => "vanin" } },
+      { :starts_at => now+200, :length => 100, :period => 300 } => { :klass => "RepeatingMockFilter3", :settings => { :vasya => "vanin" } },
+    })
+    
+    lambda {
+      filter = RepeatingFilter.new(settings, 0)
+    }.should raise_error(Exception, /Intersectings periods/)    
+  end
+  
+  it "should calculate cost correctly" do
+    @filter.calculate_cost(1, 2, Time.at(0), 3600).should == 100
+    @filter.calculate_cost(1, 2, Time.at(3600), 3600).should == 200
+    @filter.calculate_cost(1, 2, Time.at(7200), 3600).should == 300
+
+    @filter.calculate_cost(1, 2, Time.at(0), 7*24*3600).should == 33600
+    @filter.calculate_cost(1, 2, Time.at(3600+1800), 7*24*3600).should == 33600
+
+    @filter.calculate_cost(1, 2, Time.at(3600+1800), 3600+1800).should == 400
+  end
+  
+  it "should process activities correctly spanning them" do
+    unprocessed_activity = Activity.new
+    unprocessed_activity.expects(:created_at).returns(Time.at(0)).at_least_once
+    unprocessed_activity.expects(:amount).returns(7*24*3600).at_least_once
+
+    ft = FinTransaction.template
+    ft.author_id = 1
+    ft.club_id = 2
+    
+    FinTransaction.reset_transactions
+    @filter.process_activity(unprocessed_activity, ft).should == true
+    FinTransaction.transactions.inject(&:+).should == 33600
+  end
+
+  it "should process activities correctly spanning them (strict check)" do
+    unprocessed_activity = Activity.new
+    unprocessed_activity.expects(:created_at).returns(Time.at(0)).at_least_once
+    unprocessed_activity.expects(:amount).returns(3600*4+1800).at_least_once
+
+    ft = FinTransaction.template
+    ft.author_id = 1
+    ft.club_id = 2
+
+    FinTransaction.reset_transactions
+    @filter.process_activity(unprocessed_activity, ft).should == true
+    FinTransaction.transactions.should == [ 100, 200, 300, 100, 100 ]
+  end
+
+  it "should pass on the options to the underlying filter and add its own" do
+    doesnt_matter = nil
+    now = Time.at(0)
+    settings = Settings.new({
+      { :starts_at => now, :length => 3600, :period => 10800 } => { :klass => "RepeatingMockFilterWithOptionsExpectations", :settings => { :vasya => "pupkin" } },
+      { :starts_at => now+3600, :length => 3600, :period => 10800 } => { :klass => "RepeatingMockFilter2", :settings => { :vasya => "vanin" } },
+      { :starts_at => now+7200, :length => 3600, :period => 10800 } => { :klass => "RepeatingMockFilter3", :settings => { :vasya => "vanin" } }
+    })
+
+    filter = RepeatingFilter.new(settings, 0)
+
+    [ 0, 3600*3 ].each do |offset|
+      RepeatingMockFilterWithOptionsExpectations.any_instance.tap do |it|
+        it.expects(:calculate_cost).with(anything, anything, anything, anything, equals({:my => :options, :period => (0+offset...3600+offset)})).returns(0)
+        it.expects(:start_permitted?).with(anything, anything, equals({:my => :options, :period => (0+offset...3600+offset)})).returns(true)
+        it.expects(:permitted?).with(anything, anything, equals({:my => :options, :period => (0+offset...3600+offset)})).returns(true)
+        it.expects(:process_activity).with(anything, anything, equals({:my => :options, :period => (0+offset...3600+offset)})).returns(true)
+      end
+
+      Timecop.freeze(now + offset) do
+        ft_doesnt_matter = stub_everything()
+
+        activity_doesnt_matter = Activity.new
+        activity_doesnt_matter.stubs(:created_at).returns(Time.now + 30.seconds).at_least_once
+        activity_doesnt_matter.stubs(:amount).returns(3600).at_least_once
+
+        filter.calculate_cost(doesnt_matter, doesnt_matter, Time.now + 30.seconds, 3600, { :my => :options })
+        filter.start_permitted?(doesnt_matter, doesnt_matter, { :my => :options })
+        filter.permitted?(doesnt_matter, doesnt_matter, { :my => :options })
+        filter.process_activity(activity_doesnt_matter, ft_doesnt_matter, { :my => :options })
+      end
+    end
+  end
+end