arborist 0.0.1.pre20160106113421

data/spec/arborist/observer/action_spec.rb

@@ -0,0 +1,205 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../../spec_helper'
+
+require 'timecop'
+require 'arborist/observer/action'
+
+
+using Arborist::TimeRefinements
+
+
+describe Arborist::Observer::Action do
+
+	let( :event ) {{ stuff: :woo }}
+
+
+	it "can be created with just a block" do
+		result = described_class.new {}
+		expect( result ).to be_a( described_class )
+		expect( result.block ).to respond_to( :call )
+	end
+
+
+	it "is supplied the event history if the block has a second argument" do
+		history_arg = nil
+		action = described_class.new( after: 2 ) do |event, history|
+			history_arg = history
+		end
+
+		action.handle_event( event )
+		action.handle_event( event )
+
+		expect( history_arg ).to be_a( Hash )
+	end
+
+
+	it "clears the event history when the block is called" do
+		action = described_class.new( after: 2 ) {}
+		2.times { action.handle_event(event) }
+
+		expect( action.event_history ).to be_empty
+	end
+
+
+	it "requires a block" do
+		expect { described_class.new }.to raise_exception( ArgumentError, /requires a block/i )
+	end
+
+
+	context "without any other criteria" do
+
+		before( :each ) do
+			@call_count = 0
+			@last_call_arguments = nil
+		end
+
+		let( :action ) do
+			described_class.new do |args|
+				@call_count += 1
+				@last_call_arguments = args
+			end
+		end
+
+
+		it "calls its block immediately when handling an event" do
+			expect { action.handle_event(event) }.to change { @call_count }.by( 1 ).and(
+				change { @last_call_arguments }.to( event )
+			)
+		end
+
+
+	end
+
+
+	# within: 0, after: 1, during: nil
+
+
+	context "with a time threshold" do
+
+		before( :each ) do
+			@call_count = 0
+			@last_call_arguments = nil
+		end
+
+		let( :action ) do
+			described_class.new( within: 1.minute ) do |args|
+				@call_count += 1
+				@last_call_arguments = args
+			end
+		end
+
+
+		it "calls its block if two events arrive within the specified time" do
+			Timecop.freeze do
+				expect { action.handle_event(event) }.to_not change { @call_count }
+				Timecop.travel( 5.seconds ) do
+					expect { action.handle_event(event) }.to change { @call_count }.by( 1 )
+				end
+			end
+		end
+
+
+		it "calls its block if three events arrive, and the last two are within the specified time" do
+			Timecop.freeze do
+				expect { action.handle_event(event) }.to_not change { @call_count }
+				Timecop.travel( 65.seconds ) do
+					expect { action.handle_event(event) }.to_not change { @call_count }
+					Timecop.travel( 5.seconds ) do
+						expect { action.handle_event(event) }.to change { @call_count }.by( 1 )
+					end
+				end
+			end
+		end
+
+
+		it "doesn't call its block if two events arrive with more than the specified time between them" do
+			Timecop.freeze do
+				expect { action.handle_event(event) }.to_not change { @call_count }
+				Timecop.travel( 65.seconds ) do
+					expect { action.handle_event(event) }.to_not change { @call_count }
+				end
+			end
+		end
+
+
+		context "and a count threshold" do
+
+			let( :action ) do
+				described_class.new( within: 1.minute, after: 3 ) do |args|
+					@call_count += 1
+					@last_call_arguments = args
+				end
+			end
+
+			it "calls its block if the threshold number of events arrive within the specified time" do
+				Timecop.freeze do
+					expect { action.handle_event(event) }.to_not change { @call_count }
+					Timecop.travel( 5.seconds ) do
+						expect { action.handle_event(event) }.to_not change { @call_count }
+						Timecop.travel( 5.seconds ) do
+							expect { action.handle_event(event) }.to change { @call_count }.by( 1 )
+						end
+					end
+				end
+			end
+
+
+			it "doesn't call the block if the threshold number of events arrive with more than " +
+			   "the specified time between them" do
+				Timecop.freeze do
+					expect { action.handle_event(event) }.to_not change { @call_count }
+					Timecop.travel( 5.seconds ) do
+						expect { action.handle_event(event) }.to_not change { @call_count }
+						Timecop.travel( 65.seconds ) do
+							expect { action.handle_event(event) }.to_not change { @call_count }
+						end
+					end
+				end
+			end
+
+		end
+
+	end
+
+
+	context "with a count threshold" do
+		before( :each ) do
+			@call_count = 0
+			@last_call_arguments = nil
+		end
+
+		let( :action ) do
+			described_class.new( after: 2 ) do |args|
+				@call_count += 1
+				@last_call_arguments = args
+			end
+		end
+
+
+		it "calls the block if more events than count threshold have arrived" do
+			expect { action.handle_event(event) }.to_not change { @call_count }
+			expect { action.handle_event(event) }.to change { @call_count }.by( 1 )
+		end
+
+	end
+
+
+	context "with a schedule" do
+
+
+		context "with a time threshold" do
+
+			context "and a count threshold"
+
+		end
+
+
+		context "and a count threshold"
+
+	end
+
+
+end
+
+

data/spec/arborist/observer/summarize_spec.rb

@@ -0,0 +1,294 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../../spec_helper'
+
+require 'timecop'
+require 'arborist/observer/summarize'
+
+
+using Arborist::TimeRefinements
+
+
+describe Arborist::Observer::Summarize do
+
+	before( :all ) do
+		@actual_zone = ENV['TZ']
+		ENV['TZ'] = 'GMT'
+	end
+
+	after( :all ) do
+		ENV['TZ'] = @actual_zone
+	end
+
+
+	let( :event ) {{ stuff: :woo }}
+
+
+	it "can be created with just a block and a count" do
+		result = described_class.new( every: 1.minute ) {}
+		expect( result ).to be_a( described_class )
+		expect( result.block ).to respond_to( :call )
+		expect( result.time_threshold ).to eq( 1.minute )
+	end
+
+
+	it "errors if created with just a block" do
+		expect {
+			described_class.new {}
+		}.to raise_error( ArgumentError, /requires a value/i )
+	end
+
+
+	it "is supplied the event history if the block has a second argument" do
+		history_arg = nil
+		summarize = described_class.new( count: 2 ) do |history|
+			history_arg = history
+		end
+
+		summarize.handle_event( event )
+		summarize.handle_event( event )
+
+		expect( history_arg ).to be_a( Hash )
+	end
+
+
+	it "clears the event history when the block is called" do
+		summarize = described_class.new( count: 2 ) {}
+		2.times { summarize.handle_event(event) }
+
+		expect( summarize.event_history ).to be_empty
+	end
+
+
+	it "requires a block" do
+		expect {
+			described_class.new( count: 2 )
+		}.to raise_exception( ArgumentError, /requires a block/i )
+	end
+
+
+
+	# every: 0, count: 1, during: nil
+
+
+	context "with a time threshold" do
+
+		before( :each ) do
+			@call_count = 0
+			@last_call_arguments = nil
+		end
+
+		let( :summarize ) do
+			described_class.new( every: 1.minute ) do |args|
+				@call_count += 1
+				@last_call_arguments = args
+			end
+		end
+
+
+		it "calls its block if any events have arrived within the specified time" do
+			Timecop.freeze do
+				expect { summarize.handle_event(event) }.to_not change { @call_count }
+				Timecop.travel( 5.seconds ) do
+					expect { summarize.handle_event(event) }.to_not change { @call_count }
+					Timecop.travel( 55.seconds ) do
+						expect { summarize.on_timer }.to change { @call_count }.by( 1 )
+					end
+				end
+			end
+		end
+
+
+		it "doesn't call its block if no events arrive with the specified time" do
+			expect { summarize.on_timer }.to_not change { @call_count }
+		end
+
+
+		context "and a count threshold" do
+
+			let( :summarize ) do
+				described_class.new( every: 1.minute, count: 3 ) do |args|
+					@call_count += 1
+					@last_call_arguments = args
+				end
+			end
+
+			it "calls its block if the threshold number of events arrive before the specified time threshold" do
+				Timecop.freeze do
+					expect { summarize.handle_event(event) }.to_not change { @call_count }
+					Timecop.travel( 5.seconds ) do
+						expect { summarize.handle_event(event) }.to_not change { @call_count }
+						Timecop.travel( 5.seconds ) do
+							expect { summarize.handle_event(event) }.to change { @call_count }.by( 1 )
+						end
+					end
+				end
+			end
+
+
+			it "calls the block if the time threshold is met before the count threshold" do
+				Timecop.freeze do
+					expect { summarize.handle_event(event) }.to_not change { @call_count }
+					Timecop.travel( 5.seconds ) do
+						expect { summarize.handle_event(event) }.to_not change { @call_count }
+						Timecop.travel( 55.seconds ) do
+							expect { summarize.on_timer }.to change { @call_count }
+						end
+					end
+				end
+			end
+
+		end
+
+	end
+
+
+	context "with a count threshold" do
+		before( :each ) do
+			@call_count = 0
+			@last_call_arguments = nil
+		end
+
+		let( :summarize ) do
+			described_class.new( count: 2 ) do |args|
+				@call_count += 1
+				@last_call_arguments = args
+			end
+		end
+
+
+		it "calls the block if more events than count threshold have arrived" do
+			expect { summarize.handle_event(event) }.to_not change { @call_count }
+			expect { summarize.handle_event(event) }.to change { @call_count }.by( 1 )
+		end
+
+	end
+
+
+	context "with a schedule" do
+
+		before( :each ) do
+			@call_count = 0
+			@last_call_arguments = nil
+		end
+
+		let( :summarize ) do
+			# Count or every threshold is mandatory with a summary, so just use 1
+			described_class.new( count: 1, during: 'hr {9am-5pm} wd {Mon-Fri}' ) do |args|
+				@call_count += 1
+				@last_call_arguments = args
+			end
+		end
+
+
+		it "calls its block if any events arrive within the specified schedule" do
+			Timecop.freeze( '2015-11-11T08:00:00-00:00' ) do
+				expect { summarize.handle_event(event) }.to_not change { @call_count }
+				Timecop.travel( 2.hours ) do
+					expect { summarize.handle_event(event) }.to change { @call_count }.by( 1 )
+					Timecop.travel( 9.hours ) do
+						expect { summarize.on_timer }.to_not change { @call_count }
+					end
+				end
+			end
+		end
+
+
+		it "doesn't call its block if no events arrive with the specified time" do
+			expect { summarize.on_timer }.to_not change { @call_count }
+		end
+
+
+		context "and a count threshold" do
+
+			let( :summarize ) do
+				# Count or every threshold is mandatory with a summary, so just use 1
+				described_class.new( count: 3, during: 'hr {9am-5pm} wd {Mon-Fri}' ) do |args|
+					@call_count += 1
+					@last_call_arguments = args
+				end
+			end
+
+
+			it "calls its block if any events arrive within the specified schedule" do
+				Timecop.freeze( '2015-11-11T08:00:00-00:00' ) do
+					expect { summarize.handle_event(event) }.to_not change { @call_count }
+
+					Timecop.travel( 2.hours )
+					expect { summarize.handle_event(event) }.to_not change { @call_count }
+
+					Timecop.travel( 2.hours )
+					expect { summarize.handle_event(event) }.to_not change { @call_count }
+
+					Timecop.travel( 2.hours )
+					expect { summarize.handle_event(event) }.to change { @call_count }.by( 1 )
+
+					Timecop.travel( 6.hours )
+					expect { summarize.on_timer }.to_not change { @call_count }
+				end
+			end
+
+		end
+
+
+		context "and a time threshold" do
+
+			let( :summarize ) do
+				described_class.new( every: 5.minutes, during: 'hr {9am-5pm} wd {Mon-Fri}' ) do |args|
+					@call_count += 1
+					@last_call_arguments = args
+				end
+			end
+
+
+			it "calls its block on the timer if any events arrived within the specified schedule" do
+				Timecop.freeze( '2015-11-11T09:00:00-00:00' ) do
+					expect { summarize.handle_event(event) }.to_not change { @call_count }
+					Timecop.travel( 1.minute )
+					expect { summarize.handle_event(event) }.to_not change { @call_count }
+					Timecop.travel( 4.minutes )
+					expect { summarize.on_timer }.to change { @call_count }.by( 1 )
+				end
+			end
+
+
+
+			context "and a count threshold" do
+
+				let( :summarize ) do
+					described_class.new( every: 5.minutes, count: 2, during: 'hr {9am-5pm}' ) do |args|
+						@call_count += 1
+						@last_call_arguments = args
+					end
+				end
+
+
+				it "calls its block on the timer if any events arrived within the specified schedule" do
+					Timecop.freeze( '2015-11-11T09:00:00-00:00' ) do
+						expect { summarize.handle_event(event) }.to_not change { @call_count }
+						Timecop.travel( 5.minutes )
+						expect { summarize.on_timer }.to change { @call_count }.by( 1 )
+					end
+				end
+
+
+				it "calls its block on the event if it arrives within the specified schedule and " +
+				   "exceeds the count threshold" do
+					Timecop.freeze( '2015-11-11T09:00:00-00:00' ) do
+						expect { summarize.handle_event(event) }.to_not change { @call_count }
+						Timecop.travel( 1.minute )
+						expect { summarize.handle_event(event) }.to change { @call_count }.by( 1 )
+					end
+				end
+
+			end
+
+		end
+
+
+	end
+
+
+end
+
+