log2mail 0.0.1.pre2

data/spec/factories.rb

@@ -0,0 +1,101 @@
+require 'tempfile'
+
+FactoryGirl.define do
+  factory :config, class: Log2mail::Config do
+
+    trait :valid do
+      initialize_with do
+        tmp = Tempfile.new('valid_config')
+        tmp.write <<-CONFIG
+          # sample config file for log2mail
+          # comments start with '#'
+          # see source code doc/Configuration for additional information
+
+          defaults
+            sendtime   = 20
+            resendtime = 50
+            maxlines   = 7
+            template   = /tmp/mail_template
+            fromaddr   = log2mail
+            sendmail   = /usr/sbin/sendmail -oi -t
+            mailto     = global_default_recipient@example.org  # new in log2mail.rb
+          file = test.log
+            pattern = /any/
+            pattern = string match
+              mailto = special@recipient
+                maxlines = 99
+        CONFIG
+        tmp.close
+        new(tmp.path)
+      end
+    end
+
+    trait :valid_without_defaults do
+      initialize_with do
+        tmp = Tempfile.new('valid_config')
+        tmp.write <<-CONFIG
+          file = test.log
+            pattern = /any/
+            pattern = string match
+              mailto = special@recipient
+        CONFIG
+        tmp.close
+        new(tmp.path)
+      end
+    end
+
+    factory :valid_config, traits: [:valid]
+    factory :valid_config_without_defaults, traits: [:valid_without_defaults]
+  end
+
+  factory :hit, class: Log2mail::Hit do
+    matched_text "a line with string match in it\n"
+    pattern 'string match'
+    file 'test.log'
+    initialize_with{ new(matched_text, pattern, file) }
+  end
+
+  factory :report, class: Log2mail::Report do
+    recipients 'recipient@example.org'
+    hit { build(:hit) }
+
+    template do
+      tmp = Tempfile.new('valid_config')
+      tmp.write <<-TEMPLATE
+From: %f
+To: %t
+Subject: matched your pattern: %m
+
+Hello!
+
+We have matched your pattern "%m" in "%F" %n times:
+
+%l
+
+Yours,
+log2mail.
+      TEMPLATE
+      tmp.close
+      tmp.path
+    end
+
+  end
+
+  factory :file, class: Log2mail::File do
+    initialize_with do
+      tmp = Tempfile.new('file')
+      tmp.write <<-FILE
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
+eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim
+ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
+aliquip ex ea commodo consequat. Duis aute irure dolor in
+reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
+pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
+culpa qui officia deserunt mollit anim id est laborum.
+      FILE
+      tmp.close
+      new( tmp.path, ['ut'] )
+    end
+  end
+
+end

data/spec/log2mail/config_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'tempfile'
+
+module Log2mail
+
+  describe Config do
+
+    subject { build(:valid_config) }
+
+    describe '#config' do
+      it 'logs a message' do
+        expect($logger).to receive(:debug).with(/Reading configuration from/)
+        subject
+      end
+
+      context 'with defaults' do
+        it 'should return a valid config' do
+          expect($logger).not_to receive(:warn)
+          expect(subject.files).to eql(["test.log"])
+          expect(subject.defaults).to eql({
+            :sendtime   => 20,
+            :resendtime => 50,
+            :maxlines   => 7,
+            :template   => "/tmp/mail_template",
+            :fromaddr   => "log2mail",
+            :sendmail   => "/usr/sbin/sendmail -oi -t",
+            :mailtos    => ["global_default_recipient@example.org"],
+          })
+          expect(subject.patterns_for_file('test.log')).to eql(["/any/", "string match"])
+          expect(subject.mailtos_for_pattern('test.log', 'string match')).to eql(["special@recipient"])
+          expect(subject.mailtos_for_pattern('test.log', '/any/')).to eql(["global_default_recipient@example.org"])
+        end
+      end
+
+      context 'without defaults' do
+        subject { build(:valid_config_without_defaults) }
+        it 'should return a valid config' do
+          expect(subject.files).to eql(["test.log"])
+          expect(subject.defaults).to eql({})
+          expect(subject.patterns_for_file('test.log')).to eql(["/any/", "string match"])
+          expect(subject.mailtos_for_pattern('test.log', 'string match')).to eql(["special@recipient"])
+          expect(subject.mailtos_for_pattern('test.log', '/any/')).to eql([])
+        end
+        it 'should log warning when no recipients' do
+          expect($logger).to receive(:warn).with(/Pattern.*has no recipients/)
+          subject
+        end
+      end
+
+      # it { is_expected.to eql build(:config) }
+    end
+
+    describe '#files' do
+      it 'should return a list of files to watch' do
+        expect(subject.files).to be_kind_of(Array)
+        expect(subject.files).to eql(['test.log'])
+      end
+    end
+
+    describe '#patterns_for_file' do
+      it 'should return a list of patterns for file' do
+        expect(subject.patterns_for_file('test.log')).to be_kind_of(Array)
+      end
+    end
+
+    describe '#mailtos_for_pattern' do
+      it 'should return a list of recipients for file' do
+        expect(subject.mailtos_for_pattern('test.log', /any/)).to be_kind_of(Array)
+      end
+      it 'should return the global default recipient (if no sepcial recipient)' do
+        expect(subject.mailtos_for_pattern('test.log', /any/)).to eql(["global_default_recipient@example.org"])
+      end
+      it 'should return the special recipient' do
+        expect(subject.mailtos_for_pattern('test.log', 'string match')).to eql(["special@recipient"])
+      end
+    end
+
+    describe '#settings_for_mailto' do
+      it 'should return defaults, except for setting present' do
+        expect(subject.settings_for_mailto('test.log', 'string match', 'special@recipient')).to eql({
+          :sendtime   => 20,
+          :resendtime => 50,
+          :maxlines   => 99,
+          :template   => "/tmp/mail_template",
+          :fromaddr   => "log2mail",
+          :sendmail   => "/usr/sbin/sendmail -oi -t",
+        })
+      end
+      it 'should return defaults, if no setting is present' do
+        expect(subject.settings_for_mailto('test.log', 'string match', 'global_default_recipient@example.org')).to eql({
+          :sendtime   => 20,
+          :resendtime => 50,
+          :maxlines   => 7,
+          :template   => "/tmp/mail_template",
+          :fromaddr   => "log2mail",
+          :sendmail   => "/usr/sbin/sendmail -oi -t",
+        })
+      end
+    end
+
+  end
+
+end

data/spec/log2mail/file/parser_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+module Log2mail
+
+  describe File::Parser do
+
+    subject{ build(:file) }
+
+    describe '#parse' do
+
+      context 'string pattern' do
+        it 'returns the hits' do
+          expect($logger).to receive(:log).with(0, /pattern match/)
+          hits = subject.parse( IO.read(subject.path) )
+          expect(hits.count).to be(3)
+          expect(hits[0].matched_text).to eql('eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim')
+        end
+        it 'returns no hits' do
+          expect($logger).not_to receive(:log).with(0, /pattern match/)
+          hits = subject.parse( 'no hits here' )
+          expect(hits.count).to be(0)
+          expect(hits).to eql([])
+        end
+      end
+
+      context 'regexp pattern' do
+        it 'returns the hits' do
+          expect($logger).to receive(:log).with(0, /pattern match/)
+          subject.patterns = ['/ut/']
+          hits = subject.parse( IO.read(subject.path) )
+          expect(hits.count).to be(3)
+          expect(hits.map(&:matched_text)).to all( eql('ut') )
+        end
+        it 'returns no hits' do
+          expect($logger).not_to receive(:log).with(0, /pattern match/)
+          hits = subject.parse( 'no hits here' )
+          expect(hits.count).to be(0)
+          expect(hits).to eql([])
+        end
+      end
+
+      context 'mixed patterns' do
+        it 'returns the hits' do
+          expect($logger).to receive(:log).with(0, /pattern match/)
+          subject.patterns = ['/ut/i', 'dolor']
+          hits = subject.parse( IO.read(subject.path) )
+          expect(hits.count).to be(8)
+          expect(hits.map(&:matched_text)).to eql([
+            "ut", "Ut", "ut", "ut",
+            "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do",
+            "eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim",
+            "aliquip ex ea commodo consequat. Duis aute irure dolor in",
+            "reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla"
+          ])
+        end
+      end
+    end
+
+  end
+
+end

data/spec/log2mail/report_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module Log2mail
+
+  describe ReportFactory do
+
+    subject { ReportFactory.new( build(:valid_config) ) }
+    before do
+
+    end
+
+    describe '.reports_from_hit' do
+      subject { ReportFactory.new( build(:valid_config) ).reports_from_hit( build(:hit) ) }
+      it { is_expected.to be_kind_of(Array) }
+      it { is_expected.to all( be_kind_of(Log2mail::Report) ) }
+    end
+
+  end
+
+  describe Report do
+    describe '#body_from_template' do
+      subject { build(:report).send(:body_from_template) }
+      it 'should parse the template' do
+        expect(subject).to eql(<<-EOS)
+From: log2mail
+To: recipient@example.org
+Subject: matched your pattern: string match
+
+Hello!
+
+We have matched your pattern "string match" in "test.log" %n times:
+
+a line with string match in it
+
+Yours,
+log2mail.
+        EOS
+      end
+    end
+    describe '#deliver' do
+      include Mail::Matchers
+      subject { build(:report).deliver }
+      it { should have_sent_email }
+      # it 'should send the message' do
+      #   expect(subject.deliver).to change{Mail::TestMailer.deliveries.length}.by(1)
+      # end
+    end
+    describe '#sendmail_command=' do
+      let(:report){ build(:report) }
+      it 'parses the sendmail command string with parameters' do
+        report.sendmail_command = "/usr/local/sbin/sendmail -oi -t"
+        expect(report.sendmail_location).to eql('/usr/local/sbin/sendmail')
+        expect(report.sendmail_arguments).to eql('-oi -t')
+      end
+      it 'parses the sendmail command string without' do
+        report.sendmail_command = "/usr/local/sbin/sendmail"
+        expect(report.sendmail_location).to eql('/usr/local/sbin/sendmail')
+        expect(report.sendmail_arguments).to be(nil)
+      end
+    end
+  end
+
+end

data/spec/log2mail/watcher_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+module Log2mail
+
+  describe Watcher do
+    subject { Log2mail::Watcher.new( build(:valid_config ), 99 ) }
+
+    describe '#new' do
+      it 'should fail on invalid configuration' do
+        expect{ Log2mail::Watcher.new('invalid config', 99) }.to raise_error(Log2mail::Error, /Invalid configuration/)
+      end
+      it 'should init @sleeptime' do
+        expect(subject.instance_eval('@sleeptime')).to be(99)
+      end
+      it 'should init @factory' do
+        expect(subject.instance_eval('@factory')).to be_instance_of(Log2mail::ReportFactory)
+      end
+      it 'should init @files' do
+        files = subject.instance_eval('@files')
+        expect(files).to all( be_instance_of(Log2mail::File))
+        expect(files.count).to be(1)
+      end
+    end
+
+    describe '#run' do
+      let(:files) { subject.instance_eval('@files') }
+      before do
+        subject.instance_eval('@sleeptime=0')
+        expect(subject).to receive(:running?).and_return(true, false)
+      end
+      it 'should open and seek all files in the beginning' do
+        expect(subject).to receive(:open_and_seek_files)
+        subject.run
+      end
+      it 'should should check eof? for each file' do
+        files.each { |file| expect(file).to receive(:eof?).and_return(false) }
+        subject.run
+      end
+      it 'should report any hits' do
+        files.each do |file|
+          expect(file).to receive(:eof?).and_return(false)
+          hits = [build(:hit)]
+          expect(file).to receive(:parse).and_return(hits)
+          expect(subject).to receive(:report).with(hits)
+        end
+        subject.run
+      end
+
+      context 'rotated file' do
+        before do
+          allow(subject).to receive(:open_and_seek_files)
+          files.each do |file|
+            expect(file).to receive(:eof?).and_return(true)
+            expect(file).to receive(:rotated?).and_return(true)
+          end
+        end
+        it 'should reopen file if rotated' do
+          files.each do |file|
+            expect(file).to receive(:open).once
+          end
+          subject.run
+        end
+        it 'should report any hits' do
+          files.each do |file|
+            hits = [build(:hit)]
+            expect(file).to receive(:parse).and_return(hits)
+            expect(subject).to receive(:report).with(hits)
+          end
+          subject.run
+        end
+      end
+
+    end
+
+    # privates
+
+    describe '#open_and_seek_files'
+
+    describe '#log' do
+      it 'should not fail' do
+        expect{ subject.send(:log, 'a message') }.not_to raise_error
+      end
+    end
+
+    describe '#report' do
+      it 'should not fail' do
+        expect{ subject.send(:report, [build(:hit)]) }.not_to raise_error
+      end
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,112 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # RSpec
+  # spec/support/factory_girl.rb
+  require 'factory_girl'
+  config.include FactoryGirl::Syntax::Methods
+
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+
+  config.before do
+    # Log2mail.send(:remove_const, 'Logger') if defined?(Log2mail::Logger)
+    # Log2mail::Logger = spy('Logger')
+    # stub_const('Log2mail::Logger', spy('Logger') )
+    $logger = spy('Logger')
+    Mail::TestMailer.deliveries.clear
+  end
+
+
+end
+
+require 'log2mail'
+require 'factories'
+
+Mail.defaults do
+  delivery_method :test
+end