minicron 0.1.0

data/lib/minicron/transport/ssh.rb

@@ -0,0 +1,51 @@
+require 'net/ssh'
+
+module Minicron
+  module Transport
+    class SSH
+      # Set all the options for the ssh instance
+      #
+      # @option options [String] the host to connect to
+      # @option options [Integer] the port number
+      # @option options [String] the path to the private key
+      def initialize(options = {})
+        @host = options[:host]
+        @port = options[:port]
+        @private_key = File.expand_path(options[:private_key])
+
+        # TODO: Make these configurable?
+        @user = `whoami`.strip
+        @auth_methods = ['publickey']
+        @host_key = 'ssh-rsa'
+        @timeout = 10
+      end
+
+      # Open the SSH connection
+      def open
+        @ssh = Net::SSH.start(
+          @host,
+          @user,
+          {
+            :port => @port,
+            :keys => [@private_key],
+            :auth_methods => @auth_methods,
+            :host_key => @host_key,
+            :timeout => @timeout
+          }
+        )
+      end
+
+      # Execute a command on the host and block until output is returned
+      #
+      # @param command [String]
+      def exec!(command)
+        @ssh.exec!(command)
+      end
+
+      # Close the SSH connection
+      def close
+        @ssh.close
+      end
+    end
+  end
+end

data/spec/invalid_config.toml

@@ -0,0 +1,2 @@
+# Test invalid config file
+£^$YEhtglkja

data/spec/minicron/cli_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe Minicron::CLI do
+  let(:server) { Minicron::Transport::Server.new }
+  let(:thin_server) { Thin::Server }
+
+  describe '#server' do
+    it 'should start the minicron server' #do
+      # server.should_receive(:start!)
+      # server.should_receive(:running?)
+      # server.should_receive(:server)
+      # thin_server.should_receive(:new).and_return Thin::Server
+      # Thin::Server.stub(:start)
+
+      # Minicron::CLI.new.run(['server'])
+    # end
+  end
+
+  describe '#run' do
+    before :each do
+      Minicron.parse_file_config('./default.config.toml')
+    end
+
+    context 'when in --dry-run mode' do
+      it 'should run a simple command and print the output to stdout' do
+        Minicron::CLI.new.run(['run', 'echo hello', '--dry-run', '--trace']) do |output|
+          expect(output.clean).to eq 'hello'
+        end
+      end
+
+      it 'should run a simple multi-line command and print the output to stdout' do
+        command_output = ''
+
+        Minicron::CLI.new.run(['run', 'echo "hello\nworld"', '--dry-run', '--trace']) do |output|
+          command_output += output
+        end
+
+        expect(command_output.clean).to eq `echo "hello\nworld"`.clean
+      end
+
+      context 'when a non-existent command is run' do
+        it 'should return an error' do
+          Minicron.capture_output :type => :stderr do
+            expect do
+              Minicron::CLI.new.run(['lol', '--trace'])
+            end.to raise_error SystemExit
+          end
+        end
+      end
+
+      context 'when no argument is passed to the run action' do
+        it 'should raise ArgumentError' do
+          Minicron.capture_output :type => :stderr do
+            expect do
+              Minicron::CLI.new.run(['run', '--dry-run', '--trace'])
+            end.to raise_error ArgumentError
+          end
+        end
+      end
+    end
+
+    context 'when in --dry-run mode with a valid --config file passed' do
+      it 'should run a simple command and print the output to stdout' do
+        Minicron::CLI.new.run(['run', 'echo hello', '--dry-run', '--trace', '--config', './default.config.toml']) do |output|
+          expect(output.clean).to eq 'hello'
+        end
+      end
+
+      it 'should run a simple multi-line command and print the output to stdout' do
+        command_output = ''
+
+        Minicron::CLI.new.run(['run', 'echo "hello\nworld"', '--dry-run', '--trace', '--config', './default.config.toml']) do |output|
+          command_output += output
+        end
+
+        expect(command_output.clean).to eq `echo "hello\nworld"`.clean
+      end
+
+      context 'when a non-existent command is run' do
+        it 'should return an error' do
+          Minicron.capture_output :type => :stderr do
+            expect do
+              Minicron::CLI.new.run(['lol', '--trace'])
+            end.to raise_error SystemExit
+          end
+        end
+      end
+
+      context 'when no argument is passed to the run action' do
+        it 'should raise ArgumentError' do
+          Minicron.capture_output :type => :stderr do
+            expect do
+              Minicron::CLI.new.run(['run', '--dry-run', '--trace', '--config', './default.config.toml'])
+            end.to raise_error ArgumentError
+          end
+        end
+      end
+    end
+  end
+
+  describe '#run_command' do
+    context 'when in verbose mode' do
+      it 'a one line command should result in 7 total line' do
+        minicron = Minicron::CLI.new
+        minicron.disable_coloured_output!
+        output = ''
+
+        minicron.run_command('echo 1', :verbose => true) do |line|
+          output += line[:output]
+        end
+
+        expect(output.split("\n").length).to eq 7
+      end
+    end
+  end
+
+  describe '#coloured_output?' do
+    context 'when Rainbow is enabled' do
+      it 'should return true' do
+        Rainbow.enabled = true
+
+        expect(Minicron::CLI.new.coloured_output?).to eq true
+      end
+    end
+
+    context 'when Rainbow is disabled' do
+      it 'should return false' do
+        Rainbow.enabled = false
+
+        expect(Minicron::CLI.new.coloured_output?).to eq false
+      end
+    end
+  end
+
+  describe '#enable_coloured_output!' do
+    it 'should set Rainbow.enabled to true' do
+      minicron = Minicron::CLI.new
+      minicron.enable_coloured_output!
+
+      expect(Rainbow.enabled).to eq true
+      expect(minicron.coloured_output?).to eq true
+    end
+  end
+
+  describe '#disable_coloured_output!' do
+    it 'should set Rainbow.enabled to false' do
+      minicron = Minicron::CLI.new
+      minicron.disable_coloured_output!
+
+      expect(Rainbow.enabled).to eq false
+      expect(minicron.coloured_output?).to eq false
+    end
+  end
+end

data/spec/minicron/transport/client_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Minicron::Transport::Client do
+  describe '#setup' do
+    it 'should send a setup message and ensure its delivery' #do
+    #end
+  end
+end

data/spec/minicron/transport/faye/client_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Minicron::Transport::FayeClient do
+  let(:client) { Minicron::Transport::FayeClient }
+  let(:eventmachine) { EM }
+
+  describe '#initialize' do
+    it 'should set the host and queue instance variable' do
+      client_instance = client.new('http', '127.0.0.1', '80', '/test')
+      expect(client_instance.url).to eq 'http://127.0.0.1:80/test'
+      expect(client_instance.queue).to eq({})
+    end
+  end
+
+  describe '#ensure_em_running' do
+    context 'when eventmachine is not running' do
+      it 'should start eventmachine' #do
+      #   eventmachine.stub(:reactor_running?).and_return(false, true)
+      #   eventmachine.stub(:run)
+      #   eventmachine.should_receive(:reactor_running?).twice
+      #   eventmachine.should_receive(:run).once
+
+      #   client.new('http://127.0.0.1/test').ensure_em_running
+      # end
+    end
+
+    context 'when eventmachine is running' do
+      it 'should not start eventmachine' #do
+    #     eventmachine.stub(:reactor_running?).and_return true
+    #     eventmachine.should_receive(:reactor_running?).twice
+
+    #     client.new('http://127.0.0.1/test').ensure_em_running
+    #   end
+    end
+  end
+
+  describe '#ensure_delivery' do
+    before(:each) { eventmachine.stub(:stop) }
+    it 'should block until the queue hash is empty and return nil' do
+      client_instance = client.new('http', '127.0.0.1', '80', '/test')
+      client_instance.stub(:queue).and_return({ :a => 1 }, { :a => 1, :b => 2 }, { :b => 2 }, {})
+
+      client_instance.ensure_delivery
+      expect(client_instance.queue.length).to eq 0
+    end
+  end
+
+  describe '#tidy_up'
+   it 'should stop eventmachine' do
+    eventmachine.should_receive(:stop)
+    client.new('http', '127.0.0.1', '80', '/test').tidy_up
+  end
+end

data/spec/minicron/transport/server_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Minicron::Transport::Server do
+  let(:server) { Minicron::Transport::Server.new }
+  let(:thin_server) { Thin::Server }
+
+  describe '#start!' do
+    context 'when the server is running' do
+      it 'should return false' do
+        server.stub(:server).and_return thin_server
+        server.should_receive(:running?).and_return true
+
+        expect(server.start!('127.0.0.1', 1337, '/lol')).to eq false
+      end
+    end
+
+    context 'when the server is not running' do
+      it 'should return true' do
+        server.should_receive(:running?).and_return false
+        thin_server.should_receive(:new).and_return thin_server
+        thin_server.stub(:start)
+
+        expect(server.start!('127.0.0.1', 1337, '/lol')).to eq true
+      end
+    end
+  end
+
+  describe '#stop!' do
+    context 'when the server is not running' do
+      it 'should return false' do
+        server.should_receive(:running?).and_return false
+
+        expect(server.stop!).to eq false
+      end
+    end
+
+    context 'when the server is running' do
+      it 'should return true' do
+        server.should_receive(:running?).and_return true
+        server.should_receive(:server).and_return thin_server
+        server.should_receive(:server).and_return thin_server
+        thin_server.should_receive(:stop).and_return true
+
+        expect(server.stop!).to eq true
+      end
+    end
+  end
+
+  describe '#running?' do
+    context 'when the server is not running' do
+      it 'should return false' do
+        server.should_receive(:server).and_return thin_server
+        server.should_receive(:server).and_return thin_server
+        thin_server.should_receive(:running?).and_return false
+
+        expect(server.running?).to eq false
+      end
+    end
+
+    context 'when the server is running' do
+      it 'should return true' do
+        server.should_receive(:server).and_return thin_server
+        server.should_receive(:server).and_return thin_server
+        thin_server.should_receive(:running?).and_return true
+
+        expect(server.running?).to eq true
+      end
+    end
+  end
+end

data/spec/minicron/transport_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Minicron::Transport do
+  describe '.get_job_hash' do
+    context 'when the correct params are passed' do
+      it 'should return a 32 char string (md5 hash)' do
+        hash = Minicron::Transport.get_job_hash('ls', 'server1')
+
+        expect(hash.length).to eq 32
+      end
+    end
+  end
+end

data/spec/minicron_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe Minicron do
+  describe '.capture_output' do
+    context 'when :stdout is passed as an option' do
+      it 'should return a StringIO instance' do
+        output = Minicron.capture_output(:type => :stdout) do
+          $stdout.write 'I like turtles!'
+        end
+
+        expect(output).to be_an_instance_of StringIO
+      end
+    end
+
+    context 'when :stderr is passed as an option' do
+      it 'should return a StringIO instance' do
+        output = Minicron.capture_output(:type => :stderr) do
+          $stderr.write 'Quit yo jibber jabber, fool!'
+        end
+
+        expect(output).to be_an_instance_of StringIO
+      end
+    end
+
+    context 'when :both is passed as an option' do
+      it 'should return a Hash' do
+        output = Minicron.capture_output(:type => :both) do
+          $stdout.write 'I like turtles!'
+          $stderr.write 'Quit yo jibber jabber, fool!'
+        end
+
+        expect(output).to be_an_instance_of Hash
+      end
+    end
+
+    context 'when :both is passed as an option' do
+      it 'should return a Hash containing :stdout and :stderr with two StringIO instances' do
+        output = Minicron.capture_output(:type => :both) do
+          $stdout.write 'I like turtles!'
+          $stderr.write 'Quit yo jibber jabber, fool!'
+        end
+
+        expect(output).to have_key :stdout
+        expect(output).to have_key :stderr
+        expect(output[:stdout]).to be_an_instance_of StringIO
+        expect(output[:stderr]).to be_an_instance_of StringIO
+      end
+    end
+
+    context 'when an invalid :type is used' do
+      it 'should raise an ArgumentError' do
+        expect do
+          Minicron.capture_output(:type => :lol) do
+            $stdout.write 'I like turtles!'
+            $stderr.write 'Quit yo jibber jabber, fool!'
+          end
+        end.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe '.parse_file_config' do
+    context 'when a valid toml file is passed' do
+      it 'should update the config class variable with the toml file config' do
+        expected_valid_config = {
+          'global' => {
+            'verbose' => true,
+            'trace' => false
+          },
+          'client' => {
+            'scheme' => 'http',
+            'host' => '127.0.0.1',
+            'port' => 9292,
+            'path' => '/',
+            'connect_timeout' => 5,
+            'inactivity_timeout' => 5
+          },
+          'server' => {
+            'host' => '127.0.0.1',
+            'port' => 9292,
+            'path' => '/'
+          },
+          'database' => {
+            'type' => 'mysql',
+            'host' => '127.0.0.1',
+            'database' => 'minicron',
+            'username' => 'minicron',
+            'password' => 'password'
+          },
+          'cli' => {
+            'mode' => 'line',
+            'dry_run' => false
+          },
+          'alerts' => {
+            'email' => {
+              'enabled' => false,
+              'smtp' => {
+                'address' => 'localhost',
+                'port' => 25
+              }
+            },
+            'sms' => {
+              'enabled' => false
+            },
+            'pagerduty' => {
+              'enabled' => false
+            }
+          }
+        }
+
+        parse_file_config = Minicron.parse_file_config('./spec/valid_config.toml')
+        expect(parse_file_config).to eq expected_valid_config
+        expect(Minicron.config).to eq expected_valid_config
+      end
+    end
+
+    context 'when an invalid toml file is passed' do
+      it 'should update the config class variable with the toml file config' do
+        expect do
+          Minicron.parse_file_config('./spec/invalid_config.toml')
+        end.to raise_error Exception
+      end
+    end
+
+    context 'when a non existent toml file is passed' do
+      it 'should update the config class variable with the toml file config' do
+        expect do
+          Minicron.parse_file_config('./nowhere/minicron.toml')
+        end.to raise_error Exception
+      end
+    end
+  end
+end