minionizer 0.0.1 → 0.1.0

data/test/unit/lib/core/folder_creation_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+module Minionizer
+  class FolderCreationTest < MiniTest::Test
+    describe FolderCreation do
+      let(:session) { 'MockSession' }
+      let(:path) { '/foo/bar' }
+      let(:folder_creation) { FolderCreation.new(session, options) }
+
+      describe '#call' do
+
+        describe 'only path is provided' do
+          let(:options) {{ path: path }}
+
+          it 'sends the mkdir command' do
+            session.expects(:exec).with(%Q{mkdir --parents #{path}})
+            folder_creation.call
+          end
+
+        end
+
+        describe 'mode is provided' do
+          let(:mode) { '0700' }
+          let(:options) {{ path: path, mode: mode }}
+
+          it 'sets the folder permissions' do
+            session.expects(:exec).with(%Q{mkdir --parents #{path}})
+            session.expects(:exec).with(%Q{chmod #{mode} #{path}})
+            folder_creation.call
+          end
+        end
+
+        describe 'owner is provided' do
+          let(:ownername) { 'otherowner' }
+          let(:options) {{ path: path, owner: ownername }}
+
+          it 'sets the folder owner' do
+            session.expects(:exec).with(%Q{mkdir --parents #{path}})
+            session.expects(:exec).with(%Q{chown #{ownername} #{path}})
+            folder_creation.call
+          end
+        end
+
+        describe 'group is provided' do
+          let(:groupname) { 'othergroup' }
+          let(:options) {{ path: path, group: groupname }}
+
+          it 'sets the folder group' do
+            session.expects(:exec).with(%Q{mkdir --parents #{path}})
+            session.expects(:exec).with(%Q{chgrp #{groupname} #{path}})
+            folder_creation.call
+          end
+        end
+
+      end
+    end
+  end
+end

data/test/unit/lib/core/public_ssh_key_injection_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+
+module Minionizer
+  class PublicSshKeyInjectionTest < MiniTest::Test
+
+    describe PublicSshKeyInjection do
+
+      describe '#call' do
+        let(:temp_file_path) { '/tmp/foobar' }
+        let(:temp_file_pointer) { OpenStruct.new(path: temp_file_path) }
+        let(:file_injection) { 'MockFileInjection' }
+        let(:file_injection_creator) { 'MockFileInjectionCreator' }
+        let(:session) { 'MockSession' }
+        let(:username) { 'foouser' }
+        let(:key_injection_options) {{
+          target_username: username,
+          file_injection_creator: file_injection_creator
+        }}
+        let(:key_injection) { PublicSshKeyInjection.new(session, key_injection_options) }
+        let(:expected_file_injection_options) {[
+          session,
+          {
+            :source_path => temp_file_path,
+            :target_path => "~#{username}/.ssh/authorized_keys",
+            :owner => username,
+            :group => username
+          }
+        ]}
+
+        before do
+          temp_file_pointer.expects(:unlink)
+          Tempfile.expects(:new).yields(temp_file_pointer).returns(temp_file_pointer)
+          write_file('data/public_keys/foobar.pubkey', 'foobar')
+          temp_file_pointer.expects(:puts).with('foobar')
+        end
+
+        it 'injects the file' do
+          file_injection_creator.expects(:new).with(*expected_file_injection_options).returns(file_injection)
+          file_injection.expects(:call)
+
+          key_injection.call
+        end
+      end
+    end
+  end
+end

data/test/unit/lib/core/task_template_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+module Minionizer
+  class TaskTemplateTest < MiniTest::Test
+    describe TaskTemplate do
+      let(:session) { 'MockSession' }
+      let(:template) { TaskTemplate.new(session, :foo => 'bar') }
+
+      describe '#method_missing' do
+
+        it 'catches messages that match options' do
+          assert_equal('bar', template.foo)
+        end
+
+        it 'forwards unrecognized messages to super' do
+          assert_raises(NoMethodError) do
+            template.foobar
+          end
+        end
+
+      end
+
+      describe '#respond_to?' do
+
+        it 'recognizes passed in options as respondable methods' do
+          assert(template.respond_to?(:foo))
+        end
+
+        it 'properly responds to unrecognized methods' do
+          refute(template.respond_to?(:foobar))
+        end
+      end
+    end
+  end
+end

data/test/unit/lib/core/user_creation_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+module Minionizer
+  class UserCreationTest < MiniTest::Test
+    describe UserCreation do
+      let(:session) { 'MockSession' }
+      let(:full_name) { 'Test User' }
+      let(:username) { 'testuser' }
+      let(:options) {{ name: full_name, username: username }}
+      let(:user_creation) { UserCreation.new(session, options) }
+
+      describe '#call' do
+
+        describe 'user does not already exist' do
+
+          before do
+            session.stubs(:exec).with(%Q{id #{username}}).raises(CommandExecution::CommandError.new)
+          end
+
+          it 'creates the user' do
+            session.expects(:exec).with(%Q{adduser --disabled-password --gecos '#{full_name}' #{username}})
+            user_creation.call
+          end
+
+        end
+
+        describe 'user already exists' do
+
+          before do
+            session.stubs(:exec).with(%Q{id #{username}}).returns(true)
+          end
+
+          it 'does not create the user' do
+            session.expects(:exec).with(%Q{adduser --disabled-password --gecos '#{full_name}' #{username}}).never
+            user_creation.call
+          end
+
+        end
+      end
+
+    end
+  end
+end
+

data/test/unit/lib/minionizer/command_execution_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+module Minionizer
+  class CommandExecutionTest < MiniTest::Test
+
+    describe CommandExecution do
+      let(:command) { 'foo --bar' }
+      let(:connection) { 'MockConnection' }
+      let(:execution) { CommandExecution.new(connection, command) }
+
+      describe '#call' do
+        let(:channel) { 'MockChannel' }
+        let(:stdout_data) { 'stdout' }
+        let(:stderr_data) { 'stderr' }
+        let(:exit_code) { 0 }
+        let(:exit_signal) { 'exit_signal' }
+
+        before do
+          connection.stubs(:open_channel).yields(channel)
+          channel.stubs(:on_data).yields(nil, stdout_data)
+          channel.stubs(:on_extended_data).yields(nil, stderr_data)
+          channel.
+            stubs(:on_request).
+            with('exit-status').
+            yields(nil, OpenStruct.new(:read_long => exit_code))
+          channel.
+            stubs(:on_request).
+            with('exit-signal').
+            yields(nil, OpenStruct.new(:read_long => exit_signal))
+          connection.stubs(:loop)
+        end
+
+        describe 'command runs successfully' do
+
+          before do
+            channel.
+              expects(:exec).
+              with(command).
+              yields(channel, true)
+          end
+
+          it 'runs the command' do
+            execution.call
+          end
+
+        end
+
+        describe 'command fails to be invoked' do
+
+          before do
+            channel.
+              expects(:exec).
+              with(command).
+              yields(channel, false)
+          end
+
+          it 'raises InvocationError' do
+            assert_raises(CommandExecution::InvocationError) do
+              execution.call
+            end
+          end
+
+        end
+
+        describe 'command returns non-zero exit status' do
+          let(:exit_code) { 1 }
+
+          before do
+            channel.
+              expects(:exec).
+              with(command).
+              yields(channel, true)
+          end
+
+          it 'raises CommandError' do
+            assert_raises(CommandExecution::CommandError) do
+              execution.call
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/test/unit/lib/minionizer/configuration_test.rb

@@ -1,14 +1,16 @@
 require 'test_helper'
 
 module Minionizer
-  class ConfigurationTest < MiniTest::Unit::TestCase
+  class ConfigurationTest < MiniTest::Test
 
     describe Configuration do
       let(:config) { Configuration.instance }
+
       let(:minions) {{ 'foo.bar.com' => { :ssh => { :username => 'foo', :password => 'bar' } } }}
 
       before do
-        write_file('config/minions.yml', minions.to_yaml)
+        config.instance_variable_set('@minions', nil)
+        write_file('./config/minions.yml', minions.to_yaml)
       end
 
       it 'instantiates a configuration' do

data/test/unit/lib/minionizer/minion_test.rb

@@ -1,14 +1,14 @@
 require 'test_helper'
 
 module Minionizer
-  class MinionTest < MiniTest::Unit::TestCase
+  class MinionTest < MiniTest::Test
     describe Minion do
       let(:username) { 'foo' }
       let(:password) { 'bar' }
       let(:credentials) {{ 'username' => username, 'password' => password }}
       let(:config) { Configuration.instance }
       let(:fqdn) { 'foo.bar.com' }
-      let(:session_constructor) { Struct.new(:fqdn, :credentials) }
+      let(:session_constructor) { quacks_like(Session) }
       let(:minion) { Minion.new(fqdn, config, session_constructor) }
       let(:roles) { %w(foo bar) }
       let (:minion_config) {{ fqdn => { 'roles' => roles , 'ssh' => credentials } }}
@@ -22,7 +22,7 @@ module Minionizer
       end
 
       describe '#session' do
-        let(:session) { MiniTest::NamedMock.new('session') }
+        let(:session) { quacks_like_instance_of(Session) }
 
         it 'creates a session' do
           session_constructor.expects(:new).with(fqdn, credentials).returns(session)

data/test/unit/lib/minionizer/minionization_test.rb

@@ -1,28 +1,28 @@
 require 'test_helper'
 
 module Minionizer
-  class MinionizationTest < MiniTest::Unit::TestCase
+  class MinionizationTest < MiniTest::Test
 
     describe Minionization do
       let(:fqdn) { 'foo.bar.com' }
       let(:config) { Configuration.instance }
       let(:role_name) { 'web_server' }
       let(:role_class) { get_dynamic_class(role_name) }
-      let(:minion) { MiniTest::NamedMock.new('minion') }
+      let(:minion) { quacks_like_instance_of(Minion) }
       let(:minionization) { Minionization.new(arguments, config, minion_constructor) }
       let(:minion_roles) {{ fqdn => { 'roles' => [role_name] }}}
-      let(:minion_constructor) { Struct.new(:fqdn, :config) }
-      let(:session) { MiniTest::NamedMock.new('session') }
-      let(:role) { MiniTest::NamedMock.new('role') }
+      let(:minion_constructor) { quacks_like(Minion) }
+      let(:session) { quacks_like_instance_of(Session) }
+      let(:role) { quacks_like_instance_of(RoleTemplate) }
 
       before do
         config.stubs(:minions).returns(minion_roles)
-        minion.expect(:roles, [role_name])
+        minion.expects(:roles).returns([role_name])
+        minion.expects(:session).returns(session)
         minion_constructor.expects(:new).with(fqdn, config).returns(minion)
         role_class.expects(:new).with(session).returns(role)
-        role.expect(:call, true)
+        role.expects(:call)
         minionization.expects(:require).with("/roles/#{role_name}.rb")
-        minion.expect(:session, session)
       end
 
       describe 'calling with a valid minion name' do

data/test/unit/lib/minionizer/role_template_test.rb

@@ -1,10 +1,10 @@
 require 'test_helper'
 
 module Minionizer
-  class RoleTemplateTest < MiniTest::Unit::TestCase
+  class RoleTemplateTest < MiniTest::Test
 
     describe RoleTemplate do
-      let(:session) { 'MockSession' }
+      let(:session) { quacks_like_instance_of(Session) }
       let(:template) { RoleTemplate.new(session) }
 
       it 'initilizes' do

data/test/unit/lib/minionizer/session_test.rb

@@ -1,17 +1,18 @@
 require 'test_helper'
 
 module Minionizer
-  class SessionTest < MiniTest::Unit::TestCase
+  class SessionTest < MiniTest::Test
 
     describe Session do
       let(:fqdn) { 'foo.bar.com' }
       let(:username) { 'foo' }
       let(:password) { 'bar' }
       let(:credentials) {{ 'username' => username, 'password' => password }}
-      let(:connector) { MiniTest::NamedMock.new(:connector) }
-      let(:channel) { MiniTest::NamedMock.new(:channel) }
-      let(:connection) { 'MockConnection' }
-      let(:session) { Session.new(fqdn, credentials, connector) }
+      let(:connector) { mock('connector') }
+      let(:command_executor) { mock('CommandExecution') }
+      let(:execution) { mock('execution') }
+      let(:connection) { mock('connection') }
+      let(:session) { Session.new(fqdn, credentials, connector, command_executor) }
       let(:start_args) { [fqdn, username, { password: password }]}
 
       it 'instantiates' do
@@ -22,33 +23,77 @@ module Minionizer
         let(:command) { 'foobar' }
 
         before do
-          connector.expect(:start, connection, start_args)
+          connector.expects(:start).with(*start_args).returns(connection)
         end
 
-        describe 'when a single command is passed' do
+        describe '#sudo' do
+
+          describe 'with block argument' do
+
+            it 'prepends sudo onto the command line' do
+              command_executor.
+                expects(:new).
+                with(connection, sudoized(command)).
+                returns(OpenStruct.new(:call => true))
+              session.sudo do
+                session.exec(command)
+              end
+            end
+          end
+
+          describe 'with single command passed directly' do
+
+            it 'prepends sudo onto the command line' do
+              command_executor.
+                expects(:new).
+                with(connection, sudoized(command)).
+                returns(OpenStruct.new(:call => true))
+              session.sudo(command)
+            end
+
+          end
 
-          before do
-            connection.expects(:exec).with(command).returns("#{command} pong")
-            connection.expects(:loop).returns('fixme')
+          describe 'with multiple commands passed directly' do
+            let(:commands) { %w{foo bar} }
+
+            it 'prepends sudo onto each command line' do
+              commands.each do |command|
+                command_executor.
+                  expects(:new).
+                  with(connection, sudoized(command)).
+                  returns(OpenStruct.new(:call => true))
+              end
+              session.sudo(*commands)
+            end
           end
 
-          it 'returns a single result' do
-            assert_kind_of(String, session.exec(command))
+        end
+
+        describe 'when a single command is passed' do
+
+          let(:exit_code) { 0 }
+
+          it 'passes the command to the executor' do
+            command_executor.
+              expects(:new).
+              with(connection, command).
+              returns(OpenStruct.new(:call => true))
+            session.exec(command)
           end
+
         end
 
         describe 'when multiple commands are passed' do
-          let(:commands) { %w(foo bar) }
+          let(:commands) { %w{foo bar} }
 
-          before do
+          it 'passes each command individually to the executor' do
             commands.each do |command|
-              connection.expects(:exec).with(command).returns("#{command} pong")
+              command_executor.
+                expects(:new).
+                with(connection, command).
+                returns(OpenStruct.new(:call => true))
             end
-            connection.expects(:loop).twice.returns('fixme')
-          end
-
-          it 'returns multiple results' do
-            assert_kind_of(Array, session.exec(commands))
+            session.exec(*commands)
           end
         end