daf 0.3.0

data/spec/configurable_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe DAF::Configurable do
+  # Test class to verify Configurable functionality
+  class MockClass
+    include DAF::Configurable
+
+    attr_option :test, String, :required
+    attr_option :test2, Integer, :optional do |val|
+      val > 2
+    end
+
+    attr_output :test_out, String
+    attr_output :test2_out, Integer
+  end
+
+  before(:each) do
+    @under_test = MockClass.new
+  end
+
+  it 'has required option' do
+    expect { MockClass.required_options }.to_not raise_error
+    expect(MockClass.required_options).not_to be_empty
+    expect(MockClass.required_options.length).to eq(1)
+  end
+
+  it 'has options' do
+    expect { MockClass.options }.to_not raise_error
+    expect(MockClass.options).not_to be_empty
+    expect(MockClass.options.length).to eq(2)
+  end
+
+  it 'has outputs' do
+    expect { MockClass.outputs }.to_not raise_error
+    expect(MockClass.outputs).not_to be_empty
+    expect(MockClass.outputs.length).to eq(2)
+  end
+
+  it 'has readable outputs' do
+    expect { @under_test.test2_out }.to_not raise_error
+    expect { @under_test.test_out }.to_not raise_error
+  end
+
+  it 'exposes required type for inputs' do
+    expect(@under_test.test.type).to eq(String)
+    expect(@under_test.test2.type).to eq(Integer)
+  end
+
+  it 'has writable inputs' do
+    @under_test.test.value = 'Test'
+    @under_test.test2.value = 40
+    expect(@under_test.test.value).to eq('Test')
+    expect(@under_test.test2.value).to eq(40)
+  end
+
+  it 'validates inputs' do
+    @under_test.test.value = 40
+    @under_test.test2.value = 'bad value'
+    expect(@under_test.test.valid?).to eq(false)
+    expect(@under_test.test.valid?).to eq(false)
+  end
+end

data/spec/daf_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+include DAF
+
+describe 'DAF' do
+  context 'when start_dad is called' do
+    let!(:data_source) do
+      dup = class_double('DAF::YAMLDataSource').as_stubbed_const
+      allow(dup).to receive(:new)
+      dup
+    end
+
+    let!(:command) do
+      dup = class_double('DAF::Command').as_stubbed_const
+      allow(dup).to receive(:new).and_return('com')
+      dup
+    end
+
+    let!(:dir) do
+      dup = class_double('Dir').as_stubbed_const(
+        transfer_nested_constants: true)
+      allow(dup).to receive(:[]).and_return(%w(test1 test2))
+      dup
+    end
+
+    let!(:dad) do
+      dup = class_double('DAF::DynamicActionDaemon').as_stubbed_const
+      allow(dup).to receive(:new).and_return(idad)
+      dup
+    end
+
+    let(:idad) do
+      dup = double('DAF::DynamicActionDaemon')
+      allow(dup).to receive(:start)
+      dup
+    end
+
+    it 'should print usage if argument is not directory' do
+      expect(self).to receive(:print_usage)
+      ARGV[0] = '/dev/null'
+      start_dad
+    end
+
+    it 'should get list of files using Dir' do
+      expect(dir).to receive(:[]).with('//*.yaml')
+      ARGV[0] = '/'
+      start_dad
+    end
+
+    it 'should generate a list of commands from each file' do
+      expect(command).to receive(:new).twice
+      expect(data_source).to receive(:new).with('test1')
+      expect(data_source).to receive(:new).with('test2')
+      ARGV[0] = '/'
+      start_dad
+    end
+
+    it 'should create a new daemon with commands' do
+      expect(dad).to receive(:new).with(%w(com com))
+      ARGV[0] = '/'
+      start_dad
+    end
+
+    it 'should start the daemon' do
+      expect(idad).to receive(:start)
+      ARGV[0] = '/'
+      start_dad
+    end
+  end
+
+  context 'when usage information is printed' do
+    it 'should write to stdout' do
+      expect($stdout).to receive(:write).at_least(1).times
+      print_usage
+    end
+  end
+end
+
+describe 'DAF::DynamicActionDaemon' do
+  context 'when started' do
+    it 'should execute each command' do
+      command1 = double('DAF::Command')
+      command2 = double('DAF::Command')
+      expect(command1).to receive(:execute)
+      expect(command2).to receive(:execute)
+      dad = DynamicActionDaemon.new([command1, command2])
+      thread = Thread.new do
+        dad.start
+      end
+      sleep(1)
+      thread.kill
+    end
+  end
+end

data/spec/email_action_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe DAF::EmailAction do
+
+  before(:each) do
+    @server = 'mail.example.com'
+    @options = { 'from' => 'test@example.com',
+                 'to' => 'test_to@example.com',
+                 'subject' => 'Test Subject',
+                 'body' => 'Test Body',
+                 'server' => @server }
+    @action = DAF::EmailAction.new
+  end
+
+  it 'has five required options' do
+    expect { @action.class.required_options }.not_to raise_error
+    expect(@action.class.required_options.length).to eq(5)
+  end
+
+  it 'has six options' do
+    expect { @action.class.options }.not_to raise_error
+    expect(@action.class.options.length).to eq(6)
+  end
+
+  it 'has a port option of type Integer' do
+    expect(@action.class.options['port']).to eq(Integer)
+  end
+
+  context 'when activate is called' do
+    before(:each) do
+      @smtp_obj = double(Net::SMTP.new('mail.example.com'))
+      @smtp = class_double('Net::SMTP')
+              .as_stubbed_const(transfer_nested_constants: true)
+    end
+
+    it 'sends with the server and port passed in' do
+      @options['port'] = 333
+      expect(@smtp).to receive(:start).with(@server, 333)
+      @action.activate(@options)
+    end
+
+    it 'should use a default port if none is specified' do
+      expect(@smtp).to receive(:start).with(@server, 25)
+      @action.activate(@options)
+    end
+
+    it 'should send a message' do
+      target_message = <<END
+  From: test@example.com
+  To: test_to@example.com
+  Subject: Test Subject
+
+  Test Body
+END
+      allow(@smtp).to receive(:start).and_yield(@smtp_obj)
+      expect(@smtp_obj).to receive(:send_message).with(
+        target_message, 'test@example.com', 'test_to@example.com')
+      @action.activate(@options)
+    end
+  end
+end

data/spec/file_update_monitor_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe 'DAF::FileUpdateMonitor' do
+  context 'when new monitor is created' do
+    it 'should validate that the path exists' do
+      options = { 'frequency' => 2, 'path' => '/tmp/fake' }
+      expect { FileUpdateMonitor.new(options) }.to raise_error
+    end
+
+    it 'should validate that the frequency is > 1' do
+      options = { 'frequency' => 0, 'path' => '/' }
+      expect { FileUpdateMonitor.new(options) }.to raise_error
+    end
+
+    it 'should have a required option named path' do
+      expect(FileUpdateMonitor.required_options).to include('path')
+    end
+
+    it 'should have a required option named frequency' do
+      expect(FileUpdateMonitor.required_options).to include('frequency')
+    end
+  end
+
+  context 'when block_until_triggered is called' do
+    let(:monitor) do
+      options = { 'frequency' => 2, 'path' => '/' }
+      FileUpdateMonitor.new(options)
+    end
+
+    let!(:file) do
+      dup = class_double('File').as_stubbed_const(
+        transfer_nested_constants: true)
+      @time = 0
+      allow(dup).to receive(:mtime) do
+        @time += 1
+      end
+      allow(dup).to receive(:exist?).and_return(true)
+      allow(dup).to receive(:open).and_return(ifile)
+      dup
+    end
+
+    let(:ifile) do
+      dup = double('File')
+      allow(dup).to receive(:read).and_return('contents')
+      allow(dup).to receive(:close)
+      dup
+    end
+
+    it 'should sleep the set frequency' do
+      expect(monitor).to receive(:sleep).with(2)
+      monitor.block_until_triggered
+    end
+
+    it 'should record current time' do
+      expect(file).to receive(:mtime).twice
+      monitor.block_until_triggered
+    end
+
+    it 'should skip loop unless file modify time changes' do
+      expect(monitor).to receive(:sleep).with(2).exactly(3).times
+      @mtime = 0
+      allow(file).to receive(:mtime) do
+        @mtime += 1
+        if @mtime < 4
+          0
+        else
+          1
+        end
+      end
+      monitor.block_until_triggered
+    end
+
+    context 'when file is modified' do
+      it 'should record the time as output' do
+        monitor.block_until_triggered
+        expect(monitor.time).to eq(2)
+      end
+
+      it 'should record the contents of the file as output' do
+        monitor.block_until_triggered
+        expect(monitor.contents).to eq('contents')
+      end
+    end
+  end
+end

data/spec/monitor_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+# Test monitor to verify functionality
+class TestMonitor < DAF::Monitor
+  attr_option :option, String
+  attr_reader :output
+  def block_until_triggered
+    @output = 123
+  end
+end
+
+describe DAF::Monitor do
+  let(:test_monitor) { TestMonitor.new('option' => 'test') }
+
+  it 'should be configurable' do
+    mixed_in = DAF::Monitor.ancestors.select { |o| o.class == Module }
+    expect(mixed_in).to include(DAF::Configurable)
+  end
+
+  it 'should have an on_trigger method' do
+    expect(test_monitor).to respond_to(:on_trigger)
+  end
+
+  it 'should require a block to execute' do
+    expect { test_monitor.on_trigger }.to raise_error(LocalJumpError)
+  end
+
+  it 'should call block_until_triggered' do
+    test_monitor.on_trigger {}
+    expect(test_monitor.output).to eq(123)
+  end
+
+  it 'should yield to a given block when triggered' do
+    expect { |b| test_monitor.on_trigger(&b) }
+      .to yield_with_no_args
+  end
+
+  it 'should set option values' do
+    expect(test_monitor.option.value).to eq('test')
+  end
+end

data/spec/shell_action_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe DAF::ShellAction do
+  before(:each) do
+    @options = { 'path' => '/bin/ls' }
+    @action = DAF::ShellAction.new
+  end
+
+  context 'options' do
+    it 'has a required path option of type String' do
+      expect { @action.class.required_options }.not_to raise_error
+      expect(@action.class.required_options.length).to eq(1)
+    end
+
+    it 'validates the path is executable and exists' do
+      @action.path.value = '/bin/ls'
+      expect(@action.path.valid?).to eq(true)
+      @action.path.value = '/tmp/nonsense'
+      expect(@action.path.valid?).to eq(false)
+      @action.path.value = '/tmp/test1'
+      expect(@action.path.valid?).to eq(false)
+    end
+
+    it 'has an optional arguments option of type String' do
+      expect { @action.class.options }.not_to raise_error
+      expect(@action.class.options.length).to eq(2)
+    end
+  end
+
+  it 'has an output results of type String' do
+    expect { @action.class.outputs }.not_to raise_error
+    expect(@action.class.outputs.length).to eq(1)
+    expect(@action.class.outputs['results']).to eq(String)
+  end
+
+  context 'when activate is called' do
+    it 'executes a shell script' do
+      expect(@action).to receive(:`).with('/bin/ls')
+      @action.activate(@options)
+    end
+
+    it 'returns the result of shell script' do
+      allow(@action).to receive(:`).and_return('result!')
+      @action.activate(@options)
+      expect(@action.results).to eq('result!')
+    end
+
+    it 'passes arguments to the shell script' do
+      expect(@action).to receive(:`).with('/bin/ls test')
+      @options['arguments'] = 'test'
+      @action.activate(@options)
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+  add_group 'Actions', 'lib/daf/actions/'
+  add_group 'Monitors', 'lib/daf/monitors/'
+  add_group 'Data Sources', 'lib/daf/datasources/'
+  minimum_coverage 95
+  refuse_coverage_drop
+end
+
+require 'daf'
+require 'daf/command'
+require 'daf/configurable'
+require 'daf/monitor'
+require 'daf/action'
+require 'daf/monitors/file_update_monitor'
+require 'daf/actions/email_action'
+require 'daf/actions/shell_action'
+require 'daf/datasources/yaml_data_source'

data/spec/yaml_data_source_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+class TestMonitor < DAF::Monitor
+end
+
+class TestAction < DAF::Action
+end
+
+describe DAF::YAMLDataSource do
+  let!(:yaml) do
+    yaml = class_double('YAML').as_stubbed_const(
+      transfer_nested_constants: true)
+    allow(yaml).to receive(:load_file).and_return(
+      'Monitor' => { 'Options' => {}, 'Type' => 'TestMonitor' },
+      'Action' => { 'Options' => {
+        'test' => '{{test}}',
+        'test2' => 'thing: {{test2}}'
+      }, 'Type' => 'TestAction' })
+    yaml
+  end
+  let(:data_source) { DAF::YAMLDataSource.new('/tmp/test') }
+
+  context 'properties' do
+    it 'responds to #monitor' do
+      expect(data_source).to respond_to(:monitor)
+    end
+
+    it 'responds to #action' do
+      expect(data_source).to respond_to(:action)
+    end
+  end
+
+  context 'when new is called' do
+    it 'should load the file at the given path' do
+      expect(yaml).to receive(:load_file).with('/tmp/2')
+      DAF::YAMLDataSource.new('/tmp/2')
+    end
+
+    it 'should initialize monitor class specified' do
+      expect(data_source.monitor.class).to eq(TestMonitor)
+    end
+
+    it 'should initialize action class specified' do
+      expect(data_source.action.class).to eq(TestAction)
+    end
+
+    it 'should throw an exception if class does not exist' do
+      allow(yaml).to receive(:load_file).and_return(
+        'Monitor' => { 'Options' => [], 'Type' => 'BadTestMonitor' },
+        'Action' => { 'Options' => [], 'Type' => 'BadTestAction' })
+      expect { DAF::YAMLDataSource.new('/tmp/new') }.to raise_error
+    end
+  end
+
+  context 'when asked for action_options' do
+    let(:itest_action) do
+      double('TestAction')
+    end
+    let!(:test_action) do
+      dup = class_double('TestAction').as_stubbed_const
+      allow(dup).to receive(:new).and_return(itest_action)
+      dup
+    end
+    let(:itest_monitor) do
+      double('TestMonitor')
+    end
+    let!(:test_monitor) do
+      dup = class_double('TestMonitor').as_stubbed_const
+      allow(dup).to receive(:new).and_return(itest_monitor)
+      dup
+    end
+
+    it 'should return raw options if no outputs defined' do
+      allow(test_monitor).to receive(:outputs).and_return({})
+      expect(data_source.action_options).to have_key('test')
+      expect(data_source.action_options['test']).to eq('{{test}}')
+      expect(data_source.action_options).to have_key('test2')
+      expect(data_source.action_options['test2']).to eq('thing: {{test2}}')
+    end
+
+    it 'should return raw options if no outputs match outputs' do
+      allow(test_monitor).to receive(:outputs).and_return(
+        'another_test' => String
+      )
+      allow(itest_monitor).to receive(:another_test).and_return('test_output')
+      expect(data_source.action_options).to have_key('test')
+      expect(data_source.action_options['test']).to eq('{{test}}')
+      expect(data_source.action_options).to have_key('test2')
+      expect(data_source.action_options['test2']).to eq('thing: {{test2}}')
+    end
+
+    it 'should substitute outputs into options' do
+      allow(test_monitor).to receive(:outputs).and_return(
+        'test' => String
+      )
+      allow(itest_monitor).to receive(:test).and_return('test output')
+      expect(data_source.action_options).to have_key('test')
+      expect(data_source.action_options['test']).to eq('test output')
+      expect(data_source.action_options).to have_key('test2')
+      expect(data_source.action_options['test2']).to eq('thing: {{test2}}')
+    end
+
+    it 'should substitute multiple outputs into multiple inputs' do
+      allow(test_monitor).to receive(:outputs).and_return(
+        'test' => String,
+        'test2' => String
+      )
+      allow(itest_monitor).to receive(:test).and_return('test output')
+      allow(itest_monitor).to receive(:test2).and_return('aout')
+      expect(data_source.action_options).to have_key('test')
+      expect(data_source.action_options['test']).to eq('test output')
+      expect(data_source.action_options).to have_key('test2')
+      expect(data_source.action_options['test2']).to eq('thing: aout')
+    end
+
+  end
+end