fluq 0.7.5 → 0.8.0

data/spec/fluq/buffer/file_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe FluQ::Buffer::File do
-
-  let(:event) { FluQ::Event.new("some.tag", 1313131313, {}) }
-
-  it           { should be_a(FluQ::Buffer::Base) }
-  its(:config) { should == {max_size: 268435456, path: "tmp/buffers"} }
-  its(:file)   { should be_instance_of(File) }
-  its(:size)   { should == 0 }
-
-  it "should return a name" do
-    Time.stub(now: Time.at(1313131313.45678))
-    subject.name.should == "file-fb-1313131313457.1"
-  end
-
-  it "should generate unique paths" do
-    Time.stub(now: Time.at(1313131313.45678))
-    subject.file.path.should == FluQ.root.join("tmp/buffers/fb-1313131313457.1").to_s
-    described_class.new.file.path.should == FluQ.root.join("tmp/buffers/fb-1313131313457.2").to_s
-  end
-
-  it "should write data" do
-    data = event.to_msgpack
-    100.times { subject.write(data) }
-    subject.size.should == 1900
-  end
-
-  it "should drain contents" do
-    4.times { subject.write(event.to_msgpack) }
-    subject.drain do |io|
-      io.read.should == ([event.to_msgpack] * 4).join
-    end
-  end
-
-  it "should prevent writes once buffer is 'drained'" do
-    subject.write(event.to_msgpack)
-    subject.drain {|*| }
-    lambda { subject.write(event.to_msgpack) }.should raise_error(IOError, /closed/)
-  end
-
-  it "should close and unlink files" do
-    subject.write(event.to_msgpack)
-    lambda { subject.close }.should change { File.exists?(subject.file.path) }.to(false)
-  end
-
-end

data/spec/fluq/dsl_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe FluQ::DSL do
-
-  def dsl(reactor)
-    described_class.new reactor, FluQ.root.join('../scenario/config/test.rb')
-  end
-
-  subject do
-    dsl(reactor)
-  end
-
-  it 'should find & configure input' do
-    subject.input(:socket) do
-      bind 'tcp://localhost:76543'
-    end
-    subject.should have(1).inputs
-    reactor.should have(:no).inputs
-  end
-
-  it 'should find & configure handler' do
-    subject.handler(:log)
-    subject.should have(1).handlers
-    reactor.should have(:no).handlers
-  end
-
-  it 'should find namespaced handler' do
-    subject.handler(:custom, :test_handler) do
-      to 'tcp://localhost:87654'
-    end
-    subject.should have(1).handlers
-    subject.handlers.last.first.should == FluQ::Handler::Custom::TestHandler
-  end
-
-  it 'should evaluate configuration' do
-    with_reactor do |reactor|
-      dsl(reactor).run
-      reactor.should have(1).handlers
-      reactor.should have(1).inputs
-    end
-  end
-
-end

data/spec/fluq/feed/base_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe FluQ::Feed::Base do
-
-  let(:buffer) { FluQ::Buffer::Base.new }
-
-  subject do
-    described_class.new(buffer)
-  end
-
-  it { should be_a(Enumerable) }
-  its(:buffer)  { should be(buffer) }
-  its(:to_a)    { should == [] }
-
-end

data/spec/fluq/feed/json_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe FluQ::Feed::Json do
-
-  let(:buffer) { FluQ::Buffer::Base.new }
-  let(:event)  { FluQ::Event.new("some.tag", 1313131313, "a" => "b") }
-
-  before do
-    io = StringIO.new [event, event, event].map(&:to_json).join("\n")
-    buffer.stub(:drain).and_yield(io)
-  end
-
-  subject do
-    described_class.new(buffer)
-  end
-
-  it { should be_a(FluQ::Feed::Base) }
-  its(:to_a) { should == [event, event, event] }
-
-  it 'should log invalid inputs' do
-    io = StringIO.new [event.to_json, "ABCD", event.to_json].join("\n")
-    buffer.stub(:drain).and_yield(io)
-    subject.logger.should_receive(:warn).at_least(:once)
-    subject.to_a.should == [event, event]
-  end
-
-end

data/spec/fluq/feed/msgpack_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe FluQ::Feed::Msgpack do
-
-  let(:buffer) { FluQ::Buffer::Base.new }
-  let(:event)  { FluQ::Event.new("some.tag", 1313131313, "a" => "b") }
-
-  before do
-    io = StringIO.new [event, event, event].map(&:to_msgpack).join
-    buffer.stub(:drain).and_yield(io)
-  end
-
-  subject do
-    described_class.new(buffer)
-  end
-
-  it { should be_a(FluQ::Feed::Base) }
-  its(:to_a) { should == [event, event, event] }
-
-  it 'should log invalid inputs' do
-    io = StringIO.new [event.to_msgpack, "ABCD", event.to_msgpack].join
-    buffer.stub(:drain).and_yield(io)
-    subject.logger.should_receive(:warn).at_least(:once)
-    subject.to_a.should == [event, event]
-  end
-
-end

data/spec/fluq/feed/tsv_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe FluQ::Feed::Tsv do
-
-  let(:buffer) { FluQ::Buffer::Base.new }
-  let(:event)  { FluQ::Event.new("some.tag", 1313131313, "a" => "b") }
-
-  before do
-    io = StringIO.new [event, event, event].map(&:to_tsv).join("\n")
-    buffer.stub(:drain).and_yield(io)
-  end
-
-  subject do
-    described_class.new(buffer)
-  end
-
-  it { should be_a(FluQ::Feed::Base) }
-  its(:to_a) { should == [event, event, event] }
-
-  it 'should log invalid inputs' do
-    io = StringIO.new [event.to_tsv, "ABCD", event.to_tsv].join("\n")
-    buffer.stub(:drain).and_yield(io)
-    subject.logger.should_receive(:warn).at_least(:once)
-    subject.to_a.should == [event, event]
-  end
-
-end

data/spec/fluq/input/socket/connection_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe FluQ::Input::Socket::Connection do
-
-  let(:event)    { FluQ::Event.new("some.tag", 1313131313, {}) }
-  let(:input)    { FluQ::Input::Socket.new reactor, bind: "tcp://127.0.0.1:26712" }
-  before         { EventMachine.stub(:set_comm_inactivity_timeout) }
-  subject        { described_class.new(Time.now.to_i, input) }
-
-  it { should be_a(EM::Connection) }
-
-  it 'should set a timeout' do
-    EventMachine.should_receive(:set_comm_inactivity_timeout).with(instance_of(Fixnum), 60)
-    subject
-  end
-
-  it 'should handle data' do
-    subject.receive_data [event, event].map(&:to_msgpack).join
-    subject.send(:buffer).size.should == 38
-  end
-
-  it 'should flush when data transfer is complete' do
-    subject.receive_data [event, event].map(&:to_msgpack).join
-    input.should_receive(:flush!).with(instance_of(FluQ::Buffer::File))
-    subject.unbind
-  end
-
-  it 'should recover connection errors' do
-    reactor.should_receive(:process).and_raise(Errno::ECONNRESET)
-    FluQ.logger.should_receive(:crash)
-    subject.receive_data [event, event].map(&:to_msgpack).join
-    subject.unbind
-  end
-
-end

data/spec/fluq/mixins/logger_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe FluQ::Mixins::Logger do
-
-  subject do
-    logger = Logger.new("/dev/null")
-    logger.extend described_class
-    logger
-  end
-
-  its(:exception_handlers) { should == [] }
-
-  it 'should register handlers' do
-    subject.exception_handler {|*| }
-    subject.should have(1).exception_handlers
-  end
-
-  it 'should apply handlers on crash' do
-    str = ""
-    subject.exception_handler {|ex| str << ex.message }
-    subject.crash("error", StandardError.new("something"))
-    str.should == "something"
-  end
-
-end

data/spec/fluq/reactor_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe FluQ::Reactor do
-
-  its(:handlers)    { should == [] }
-  its(:inputs)      { should == [] }
-  before            { FluQ::Testing.exceptions.clear }
-
-  def events(*tags)
-    tags.map do |tag|
-      FluQ::Event.new(tag, 1313131313, {})
-    end
-  end
-
-  it "should listen to inputs" do
-    with_reactor do |subject|
-      subject.listen(FluQ::Input::Socket, bind: "tcp://127.0.0.1:7654")
-      subject.should have(1).inputs
-    end
-  end
-
-  it "should register handlers" do
-    h1 = subject.register(FluQ::Handler::Test)
-    subject.should have(1).handlers
-
-    h2 = subject.register(FluQ::Handler::Test, name: "specific")
-    subject.should have(2).handlers
-  end
-
-  it "should prevent duplicates" do
-    subject.register(FluQ::Handler::Test)
-    lambda {
-      subject.register(FluQ::Handler::Test)
-    }.should raise_error(ArgumentError)
-  end
-
-  it "should process events" do
-    h1 = subject.register(FluQ::Handler::Test)
-    h2 = subject.register(FluQ::Handler::Test, pattern: "NONE")
-    subject.process(events("tag")).should be(true)
-    h1.events.should == [["tag", 1313131313, {}]]
-    h2.events.should == []
-  end
-
-  it "should skip not matching events" do
-    h1 = subject.register(FluQ::Handler::Test, pattern: "some*")
-    subject.process(events("some.tag", "other.tag", "something.else")).should be(true)
-    h1.events.should == [["some.tag", 1313131313, {}], ["something.else", 1313131313, {}]]
-  end
-
-  it "should recover crashed handlers gracefully" do
-    h1 = subject.register(FluQ::Handler::Test)
-    10.times { subject.process(events("ok.now")) }
-    subject.process(events("error.event"))
-    10.times { subject.process(events("ok.now")) }
-    h1.should have(20).events
-    FluQ::Testing.should have(1).exceptions
-    FluQ::Testing.exceptions.last.should be_instance_of(RuntimeError)
-  end
-
-  it "should recover timeouts" do
-    h1 = subject.register(FluQ::Handler::Test, timeout: 0.001)
-    h1.events.should_receive(:concat).and_return {|*| sleep(0.01) }
-    subject.process [FluQ::Event.new("ok.event", Time.now.to_i, "sleep" => 0.05)]
-    FluQ::Testing.should have(1).exceptions
-    FluQ::Testing.exceptions.last.should be_instance_of(Timeout::Error)
-  end
-
-end

data/spec/scenario/config/nested/common.rb

@@ -1,3 +0,0 @@
-input :socket do
-  bind 'tcp://localhost:7654'
-end