yell 2.2.0 → 2.2.1

data/spec/yell/adapters/base_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Adapters::Base do
-
-  context "initialize" do
-    context ":level" do
-      let(:level) { Yell::Level.new(:warn) }
-
-      it "should set the level" do
-        adapter = Yell::Adapters::Base.new(:level => level)
-
-        expect(adapter.level).to eq(level)
-      end
-
-      it "should set the level when block was given" do
-        adapter = Yell::Adapters::Base.new { |a| a.level = level }
-
-        expect(adapter.level).to eq(level)
-      end
-    end
-  end
-
-  context "#write" do
-    let(:logger) { Yell::Logger.new }
-    let(:adapter) { Yell::Adapters::Base.new(:level => 1) }
-
-    it "should delegate :event to :write!" do
-      event = Yell::Event.new(logger, 1, "Hello World!")
-      expect(adapter).to receive(:write!).with(event)
-
-      adapter.write(event)
-    end
-
-    it "should not write when event does not have the right level" do
-      event = Yell::Event.new(logger, 0, "Hello World!")
-      expect(adapter).to_not receive(:write!)
-
-      adapter.write(event)
-    end
-  end
-
-end
-

data/spec/yell/adapters/datefile_spec.rb

@@ -1,168 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Adapters::Datefile do
-  let(:logger) { Yell::Logger.new }
-  let(:message) { "Hello World" }
-  let(:event) { Yell::Event.new(logger, 1, message) }
-
-  let(:today) { Time.now }
-  let(:tomorrow) { Time.now + 86400 }
-
-  let(:filename) { fixture_path + '/test.log' }
-  let(:today_filename) { fixture_path + "/test.#{today.strftime(Yell::Adapters::Datefile::DefaultDatePattern)}.log" }
-  let(:tomorrow_filename) { fixture_path + "/test.#{tomorrow.strftime(Yell::Adapters::Datefile::DefaultDatePattern)}.log" }
-
-  let(:adapter) { Yell::Adapters::Datefile.new(:filename => filename, :format => "%m") }
-
-  before do
-    Timecop.freeze(today)
-  end
-
-  it { should be_kind_of Yell::Adapters::File }
-
-  describe "#write" do
-    let(:today_lines) { File.readlines(today_filename) }
-
-    before do
-      adapter.write(event)
-    end
-
-    it "should be output to filename with date pattern" do
-      expect(File.exist?(today_filename)).to be_truthy
-
-      expect(today_lines.size).to eq(2) # includes header line
-      expect(today_lines.last).to match(message)
-    end
-
-    it "should output to the same file" do
-      adapter.write(event)
-
-      expect(File.exist?(today_filename)).to be_truthy
-      expect(today_lines.size).to eq(3) # includes header line
-    end
-
-    it "should not open file handle again" do
-      expect(File).to_not receive(:open)
-
-      adapter.write(event)
-    end
-
-    context "on rollover" do
-      let(:tomorrow_lines) { File.readlines(tomorrow_filename) }
-
-      before do
-        Timecop.freeze(tomorrow) { adapter.write(event) }
-      end
-
-      it "should rotate file" do
-        expect(File.exist?(tomorrow_filename)).to be_truthy
-
-        expect(tomorrow_lines.size).to eq(2) # includes header line
-        expect(tomorrow_lines.last).to match(message)
-      end
-    end
-  end
-
-  describe "#keep" do
-    before do
-      adapter.symlink = false # to not taint the Dir
-      adapter.keep = 2
-
-      adapter.write(event)
-    end
-
-    it "should keep the specified number or files upon rollover" do
-      expect(Dir[fixture_path + '/*.log'].size).to eq(1)
-
-      Timecop.freeze(tomorrow) { adapter.write(event) }
-      expect(Dir[fixture_path + '/*.log'].size).to eq(2)
-
-      Timecop.freeze(tomorrow + 86400 ) { adapter.write(event) }
-      expect(Dir[fixture_path + '/*.log'].size).to eq(2)
-    end
-  end
-
-  describe "#symlink" do
-    context "when true (default)" do
-      before do
-        adapter.write(event)
-      end
-
-      it "should be created on the original filename" do
-        expect(File.symlink?(filename)).to be_truthy
-        expect(File.readlink(filename)).to eq(today_filename)
-      end
-
-      it "should be recreated upon rollover" do
-        Timecop.freeze(tomorrow) { adapter.write(event) }
-
-        expect(File.symlink?(filename)).to be_truthy
-        expect(File.readlink(filename)).to eq(tomorrow_filename)
-      end
-    end
-
-    context "when false" do
-      before do
-        adapter.symlink = false
-      end
-
-      it "should not create the sylink the original filename" do
-        adapter.write( event )
-
-        expect(File.symlink?(filename)).to be_falsey
-      end
-    end
-  end
-
-  describe "#header" do
-    let(:header) { File.open(today_filename, &:readline) }
-
-    context "when true (default)" do
-      before do
-        adapter.write(event)
-      end
-
-      it "should be written" do
-        expect(header).to match(Yell::Adapters::Datefile::HeaderRegexp)
-      end
-
-      it "should be rewritten upon rollover" do
-        Timecop.freeze(tomorrow) { adapter.write(event) }
-
-        expect(File.symlink?(filename)).to be_truthy
-        expect(File.readlink(filename)).to eq(tomorrow_filename)
-      end
-    end
-
-    context "when false" do
-      before do
-        adapter.header = false
-      end
-
-      it "should not be written" do
-        adapter.write(event)
-
-        expect(header).to eq("Hello World\n")
-      end
-    end
-  end
-
-  context "another adapter with the same :filename" do
-    let(:another_adapter) { Yell::Adapters::Datefile.new(:filename => filename) }
-
-    before do
-      adapter.write(event)
-    end
-
-    it "should not write the header again" do
-      another_adapter.write(event)
-
-      # 1: header
-      # 2: adapter write
-      # 3: another_adapter: write
-      expect(File.readlines(today_filename).size).to eq(3)
-    end
-  end
-
-end
-

data/spec/yell/adapters/file_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Adapters::File do
-  let(:devnull) { File.new('/dev/null', 'w') }
-
-  before do
-    allow(File).to receive(:open) { devnull }
-  end
-
-  it { should be_kind_of(Yell::Adapters::Io) }
-
-  context "#stream" do
-    subject { Yell::Adapters::File.new.send(:stream) }
-
-    it { should be_kind_of(File) }
-  end
-
-  context "#write" do
-    let(:logger) { Yell::Logger.new }
-    let(:event) { Yell::Event.new(logger, 1, "Hello World") }
-
-    context "default filename" do
-      let(:filename) { File.expand_path "#{Yell.env}.log" }
-      let(:adapter) { Yell::Adapters::File.new }
-
-      it "should print to file" do
-        expect(File).to(
-          receive(:open).
-            with(filename, File::WRONLY|File::APPEND|File::CREAT) { devnull }
-        )
-
-        adapter.write(event)
-      end
-    end
-
-    context "with given :filename" do
-      let(:filename) { fixture_path + '/filename.log' }
-      let(:adapter) { Yell::Adapters::File.new(:filename => filename) }
-
-      it "should print to file" do
-        expect(File).to(
-          receive(:open).
-            with(filename, File::WRONLY|File::APPEND|File::CREAT) { devnull }
-        )
-
-        adapter.write(event)
-      end
-    end
-
-    context "with given :pathname" do
-      let(:pathname) { Pathname.new(fixture_path).join('filename.log') }
-      let(:adapter) { Yell::Adapters::File.new( :filename => pathname ) }
-
-      it "should accept pathanme as filename" do
-        expect(File).to(
-          receive(:open).
-            with(pathname.to_s, File::WRONLY|File::APPEND|File::CREAT) { devnull }
-        )
-
-        adapter.write(event)
-      end
-    end
-
-    context "#sync" do
-      let(:adapter) { Yell::Adapters::File.new }
-
-      it "should sync by default" do
-        expect(devnull).to receive(:sync=).with(true)
-
-        adapter.write(event)
-      end
-
-      it "pass the option to File" do
-        adapter.sync = false
-
-        expect(devnull).to receive(:sync=).with(false)
-
-        adapter.write(event)
-      end
-    end
-  end
-
-end
-

data/spec/yell/adapters/io_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Adapters::Io do
-  it { should be_kind_of Yell::Adapters::Base }
-
-  context "initialize" do
-    it "should set default :format" do
-      adapter = Yell::Adapters::Io.new
-
-      expect(adapter.format).to be_kind_of(Yell::Formatter)
-    end
-
-    context ":level" do
-      let(:level) { Yell::Level.new(:warn) }
-
-      it "should set the level" do
-        adapter = Yell::Adapters::Io.new(:level => level)
-
-        expect(adapter.level).to eq(level)
-      end
-
-      it "should set the level when block was given" do
-        adapter = Yell::Adapters::Io.new { |a| a.level = level }
-
-        expect(adapter.level).to eq(level)
-      end
-    end
-
-    context ":format" do
-      let(:format) { Yell::Formatter.new }
-
-      it "should set the level" do
-        adapter = Yell::Adapters::Io.new(:format => format)
-
-        expect(adapter.format).to eq(format)
-      end
-
-      it "should set the level when block was given" do
-        adapter = Yell::Adapters::Io.new { |a| a.format = format }
-
-        expect(adapter.format).to eq(format)
-      end
-    end
-  end
-
-  context "#write" do
-    let(:logger) { Yell::Logger.new }
-    let(:event) { Yell::Event.new(logger, 1, "Hello World") }
-    let(:adapter) { Yell::Adapters::Io.new }
-    let(:stream) { File.new('/dev/null', 'w') }
-
-    before do
-      allow(adapter).to receive(:stream) { stream }
-    end
-
-    it "should format the message" do
-      expect(adapter.format).to(
-        receive(:call).with(event).and_call_original
-      )
-
-      adapter.write(event)
-    end
-
-    it "should print formatted message to stream" do
-      formatted = Yell::Formatter.new.call(event)
-      expect(stream).to receive(:syswrite).with(formatted)
-
-      adapter.write(event)
-    end
-  end
-end

data/spec/yell/adapters/streams_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Adapters::Stdout do
-
-  it { should be_kind_of(Yell::Adapters::Io) }
-
-  context "#stream" do
-    subject { Yell::Adapters::Stdout.new.send :stream }
-
-    it { should be_kind_of(IO) }
-  end
-
-end
-
-describe Yell::Adapters::Stderr do
-
-  it { should be_kind_of(Yell::Adapters::Io) }
-
-  context "#stream" do
-    subject { Yell::Adapters::Stderr.new.send(:stream) }
-
-    it { should be_kind_of(IO) }
-  end
-
-end
-

data/spec/yell/adapters_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Adapters do
-
-  context ".new" do
-    it "should accept an adapter instance" do
-      stdout = Yell::Adapters::Stdout.new
-      adapter = Yell::Adapters.new(stdout)
-
-      expect(adapter).to eq(stdout)
-    end
-
-    it "should accept STDOUT" do
-      expect(Yell::Adapters::Stdout).to receive(:new).with(anything)
-
-      Yell::Adapters.new(STDOUT)
-    end
-
-    it "should accept STDERR" do
-      expect(Yell::Adapters::Stderr).to receive(:new).with(anything)
-
-      Yell::Adapters.new(STDERR)
-    end
-
-    it "should raise an unregistered adapter" do
-      expect {
-        Yell::Adapters.new(:unknown)
-      }.to raise_error(Yell::AdapterNotFound)
-    end
-  end
-
-  context ".register" do
-    let(:type) { :test }
-    let(:klass) { double }
-
-    it "should allow to being called from :new" do
-      Yell::Adapters.register(type, klass)
-      expect(klass).to receive(:new).with(anything)
-
-      Yell::Adapters.new(type)
-    end
-  end
-end

data/spec/yell/configuration_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Configuration do
-
-  describe ".load!" do
-    let(:file) { fixture_path + '/yell.yml' }
-    let(:config) { Yell::Configuration.load!(file) }
-
-    subject { config }
-
-    it { should be_kind_of(Hash) }
-    it { should have_key(:level) }
-    it { should have_key(:adapters) }
-
-    context ":level" do
-      subject { config[:level] }
-
-      it { should eq("info") }
-    end
-
-    context ":adapters" do
-      subject { config[:adapters] }
-
-      it { should be_kind_of(Array) }
-
-      # stdout
-      it { expect(subject.first).to eq(:stdout) }
-
-      # stderr
-      it { expect(subject.last).to be_kind_of(Hash) }
-      it { expect(subject.last).to eq(:stderr => {:level => 'gte.error'}) }
-    end
-  end
-
-end
-