Skip to content
This repository has been archived by the owner on Sep 30, 2018. It is now read-only.

Commit

Permalink
Cleanup some specs
Browse files Browse the repository at this point in the history
adambeynon committed Nov 29, 2013

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature. The key has expired.
1 parent 4c009d8 commit b5a3bbc
Showing 1 changed file with 27 additions and 27 deletions.
54 changes: 27 additions & 27 deletions spec/eventable_spec.rb
Original file line number Diff line number Diff line change
@@ -9,84 +9,84 @@ def events
end

describe Vienna::Eventable do

let(:obj) { EventableSpec.new }
subject { EventableSpec.new }

describe "#on" do
it "should register event handlers for given name" do
handler = Proc.new {}
obj.on(:foo, &handler)
obj.events[:foo].should == [handler]
subject.on(:foo, &handler)

expect(subject.events[:foo]).to eq([handler])
end

it "returns the given handler" do
handler = Proc.new {}
obj.on(:foo, &handler).should eq(handler)
expect(subject.on(:foo, &handler)).to eq(handler)
end
end

describe "#off" do
it "has no affect if no handlers defined at all" do
obj.off(:bar, proc {})
obj.on(:foo) { raise "err" }
obj.off(:bar, proc {})
subject.off(:bar, proc {})
subject.on(:foo) { raise "err" }
subject.off(:bar, proc {})
end

it "removes the handler for the event" do
called = false
handler = obj.on(:foo) { called = true }
handler = subject.on(:foo) { called = true }

obj.off(:foo, handler)
obj.trigger(:foo)
called.should eq(false)
subject.off(:foo, handler)
subject.trigger(:foo)
expect(called).to be_falsy
end
end

describe "#trigger" do
it "should call handler" do
called = false

obj.on(:foo) { called = true }
subject.on(:foo) { called = true }
called.should == false

obj.trigger(:foo)
subject.trigger(:foo)
called.should == true
end

it "should pass all arguments to handler" do
args = nil
obj.on(:foo) { |*a| args = a }
subject.on(:foo) { |*a| args = a }

obj.trigger(:foo)
subject.trigger(:foo)
args.should == []

obj.trigger(:foo, 1)
subject.trigger(:foo, 1)
args.should == [1]

obj.trigger(:foo, 1, 2, 3)
subject.trigger(:foo, 1, 2, 3)
args.should == [1, 2, 3]
end

it "should allow multiple different events to be registered" do
result = []
obj.on(:foo) { result << :foo }
obj.on(:bar) { result << :bar }
subject.on(:foo) { result << :foo }
subject.on(:bar) { result << :bar }

obj.trigger(:foo)
subject.trigger(:foo)
result.should == [:foo]

obj.trigger(:bar)
subject.trigger(:bar)
result.should == [:foo, :bar]
end

it "should allow multiple handlers for an event" do
count = 0

obj.on(:foo) { count += 1 }
obj.on(:foo) { count += 1 }
obj.on(:foo) { count += 1 }
obj.on(:foo) { count += 1 }
obj.trigger(:foo)
subject.on(:foo) { count += 1 }
subject.on(:foo) { count += 1 }
subject.on(:foo) { count += 1 }
subject.on(:foo) { count += 1 }
subject.trigger(:foo)

count.should == 4
end

0 comments on commit b5a3bbc

Please sign in to comment.