minionizer 0.0.1 → 0.1.0

data/test/integration/core_library_test.rb

@@ -0,0 +1,193 @@
+require 'test_helper'
+require 'fileutils'
+
+module Minionizer
+  class MinionTestFailure < StandardError; end
+  class CoreLibraryTest < MiniTest::Test
+    roll_back_to_blank_snapshot if minion_available?
+
+    describe 'core library' do
+      let(:fqdn) { '192.168.49.181' }
+      let(:username) { 'vagrant' }
+      let(:password) { 'vagrant' }
+      let(:credentials) {{ 'username' => username, 'password' => password }}
+      let(:session) { Session.new(fqdn, credentials) }
+      let(:minionization) { Minionization.new([fqdn], Configuration.instance) }
+      let(:minions) {{ fqdn => { 'ssh' => credentials, 'roles' => ['test_role'] } }}
+
+      before do
+        skip unless minion_available?
+        Configuration.instance.instance_variable_set(:@minions, nil)
+        write_file('config/minions.yml', minions.to_yaml)
+        create_role(code)
+      end
+
+      describe UserCreation do
+        let(:new_name) { 'Test User' }
+        let(:new_username) { 'testuser' }
+        let(:options) {{ name: new_name, username: new_username }}
+        let(:code) { %Q{
+          session.sudo do
+            Minionizer::UserCreation.new( session, #{options}).call
+          end
+        } }
+
+        before do
+          refute_user_exists(new_username)
+        end
+
+        it 'creates a user' do
+          2.times { assert_throws(:high_five) { minionization.call } }
+          assert_user_exists(new_username)
+        end
+      end
+
+      describe FolderCreation do
+        let(:filename) { "foo/dir" }
+        let(:ownername) { 'otheruser' }
+        let(:path) { "/home/vagrant/#{filename}" }
+        let(:options) {{ path: path, mode: '0700', owner: ownername, group: ownername }}
+        let(:code) { %Q{
+          session.sudo do
+            Minionizer::FolderCreation.new( session, #{options}).call
+          end
+        } }
+
+        before do
+          refute_directory_exists(path)
+          session.sudo("adduser --disabled-password --gecos '#{ownername}'  #{ownername}")
+        end
+
+        after do
+          skip unless minion_available?
+          session.sudo("userdel #{ownername}")
+        end
+
+        it 'creates a folder' do
+          2.times { assert_throws(:high_five) { minionization.call } }
+          assert_directory_exists(path)
+          mode = session.exec("stat --format=%a #{path}")[:stdout]
+          assert_equal('700',mode)
+          owner = session.exec("stat --format=%U #{path}")[:stdout]
+          assert_equal(ownername, owner)
+          group = session.exec("stat --format=%G #{path}")[:stdout]
+          assert_equal(ownername, group)
+        end
+      end
+
+      describe FileInjection do
+        let(:filename) { 'foobar.txt' }
+        let(:source_path) { "/some/source/#{filename}" }
+        let(:target_path) { "/home/vagrant/#{filename}" }
+        let(:ownername) { 'otheruser' }
+        let(:options) {{
+          source_path: source_path,
+          target_path: target_path,
+          mode: '0700',
+          owner: ownername,
+          group: ownername
+        }}
+        let(:code) { %Q{
+          session.sudo do
+            Minionizer::FileInjection.new( session, #{options}).call
+          end
+        } }
+
+        before do
+          refute_file_exists(target_path)
+          write_file(source_path, 'FooBar')
+          session.sudo("adduser --disabled-password --gecos '#{ownername}'  #{ownername}")
+        end
+
+        after do
+          skip unless minion_available?
+          session.sudo("userdel #{ownername}")
+        end
+
+        it 'injects a file' do
+          2.times { assert_throws(:high_five) { minionization.call } }
+          assert_file_exists(target_path)
+          mode = session.exec("stat --format=%a #{target_path}")[:stdout]
+          assert_equal('700',mode)
+          owner = session.exec("stat --format=%U #{target_path}")[:stdout]
+          assert_equal(ownername, owner)
+          group = session.exec("stat --format=%G #{target_path}")[:stdout]
+          assert_equal(ownername, group)
+        end
+      end
+
+      describe PublicSshKeyInjection do
+        let(:source_path) { "data/public_keys" }
+        let(:target_username) { 'otheruser' }
+        let(:options) {{ target_username: target_username }}
+        let(:code) { %Q{
+          session.sudo do |sudo_session|
+            Minionizer::PublicSshKeyInjection.new(sudo_session, #{options}).call
+          end
+        } }
+
+        before do
+          Dir.mkdir('/tmp')
+          refute_file_exists("~#{target_username}/.ssh/authorized_keys")
+          write_file("#{source_path}/foobar.pubkey", 'FooBar')
+          write_file("#{source_path}/foobaz.pubkey", 'FooBaz')
+          session.exec("sudo adduser --disabled-password --gecos '#{target_username}'  #{target_username}")
+        end
+
+        after do
+          File.delete("#{source_path}/foobar.pubkey")
+          File.delete("#{source_path}/foobaz.pubkey")
+        end
+
+        it 'injects public keys' do
+          2.times { assert_throws(:high_five) { minionization.call } }
+          assert_file_exists("~#{target_username}/.ssh/authorized_keys")
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def create_role(injected_code)
+        role_code = without_fakefs do
+          ERB.new(File.open('test/role_template.rb.erb').read.strip).result(binding)
+        end
+        write_file('roles/test_role.rb', role_code)
+      end
+
+      def assert_file_exists(path)
+        assert(link_exists?(path, :f), "#{path} file expected to exist")
+      end
+
+      def refute_file_exists(path)
+        refute(link_exists?(path, :f), "#{path} file NOT expected to exist")
+      end
+
+      def assert_directory_exists(path)
+        assert(link_exists?(path, :d), "#{path} directory expected to exist")
+      end
+
+      def refute_directory_exists(path)
+        refute(link_exists?(path, :d), "#{path} directory NOT expected to exist")
+      end
+
+      def link_exists?(path, parameter = :e)
+        session.exec("[ -#{parameter} #{path} ] && echo 'yes' || echo 'no'")[:stdout] == 'yes'
+      end
+
+      def assert_user_exists(username)
+        assert(user_exists?(username), "User '#{username}' expected to exist")
+      end
+
+      def refute_user_exists(username)
+        refute(user_exists?(username), "User '#{username}' expected to NOT exist")
+      end
+
+      def user_exists?(username)
+        session.exec("id #{username} || echo 'no'")[:stdout] != 'no'
+      end
+
+    end
+  end
+end

data/test/role_template.rb.erb

@@ -0,0 +1,16 @@
+class TestRole < Minionizer::RoleTemplate
+
+  def call
+    if hostname == 'precise32'
+      <%= injected_code %>
+      throw :high_five
+    else
+      raise Minionizer::MinionTestFailure.new("Whawhawhaaaa... #{hostname}")
+    end
+  end
+
+  def hostname
+    @hostname ||= session.exec(:hostname)[:stdout]
+  end
+
+end

data/test/test_helper.rb

@@ -1,13 +1,24 @@
 require 'rubygems'
+require 'simplecov'
+require 'coveralls'
 require 'minitest/autorun'
 require 'fakefs/safe'
 require 'socket'
+require 'tempfile'
 require 'timeout'
 
+if Coveralls.will_run?
+  Coveralls.wear!
+else
+  SimpleCov.start
+end
+
+PRE_REQUIRED_LIBS = %w{tempfile}
+
 require_relative '../lib/minionizer'
 
 module Minionizer
-  class MiniTest::Unit::TestCase
+  class MiniTest::Test
 
     def before_setup
       super
@@ -17,6 +28,9 @@ module Minionizer
     def after_teardown
       super
       FakeFS.deactivate!
+      Kernel.class_eval do
+        alias_method :require, :real_require
+      end
     end
 
     #######
@@ -25,17 +39,44 @@ module Minionizer
 
     def initialize_fakefs
       FakeFS.activate!
-      FakeFS::FileSystem.clear
       Kernel.class_eval do
+        def fake_require(path)
+          if PRE_REQUIRED_LIBS.include?(path)
+            return false #real require returns false if library is already loaded
+          else
+            File.open(path, "r") {|f| Object.class_eval f.read, path, 1 }
+          end
+        end
+        alias_method :real_require, :require
         alias_method :require, :fake_require
       end
     end
 
+    def without_fakefs
+      FakeFS.deactivate!
+      yield
+    ensure
+      FakeFS.activate!
+    end
+
     def minion_available?
-      Timeout.timeout(1) do
-        @@minion_available ||= TCPSocket.new('192.168.49.181', 22)
+      self.class.minion_available?
+    end
+
+    def self.minion_available?
+      if MinionMonitor.minion_available?
+        return true
+      else
+        Timeout.timeout(1) do
+          if Net::SSH.start('192.168.49.181', 'vagrant', password: 'vagrant')
+            MinionMonitor.minion_available!
+            return true
+          else
+            return false
+          end
+        end
       end
-    rescue Errno::ECONNREFUSED, Timeout::Error
+    rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Timeout::Error
       return false
     end
 
@@ -43,10 +84,8 @@ module Minionizer
       @@previously_initialized ||= `cd #{File.dirname(__FILE__)}; vagrant up`
     end
 
-    def roll_back_to_blank_snapshot
-      FakeFS.deactivate!
+    def self.roll_back_to_blank_snapshot
       `cd #{File.dirname(__FILE__)}; vagrant snapshot go blank-test-slate`
-      FakeFS.activate!
     end
 
     def write_role_file(name)
@@ -64,38 +103,92 @@ module Minionizer
       Object.const_set(name.classify, Class.new)
     end
 
-  end
-end
+    def quacks_like(klass)
+      mock("Mock(#{klass.to_s})").tap do |object|
+        object.responds_like(klass)
+      end
+    end
+
+    def quacks_like_instance_of(klass)
+      mock("InstanceMock(#{klass.to_s})").tap do |object|
+        object.responds_like_instance_of(klass)
+      end
+    end
 
-module Kernel
+    def assert_equal(first, second)
+      assert(first === second, "'#{second}' expected to be equal to '#{first}'")
+    end
 
-  def fake_require(path)
-    File.open(path, "r") {|f| Object.class_eval f.read, path, 1 }
+    def sudoized(command)
+      %Q{sudo bash -c "#{command}"}
+    end
   end
-
 end
 
-module MiniTest
-  class NamedMock < Mock
-    attr_reader :name
-
-    def initialize(name)
-      @name = name
-      super()
-    end
+require 'mocha/setup'
 
-    # Because you ought to be able to
-    # test two effing mocks for equality.
-    def ==(x)
-      object_id == x.object_id
-    end
+module MinionMonitor
+  def self.minion_available?; !!@minion_available; end
+  def self.minion_available!; @minion_available = true; end
+end
 
-    def method_missing(sym, *args, &block)
-      super(sym, *args, &block)
-    rescue NoMethodError, MockExpectationError, ArgumentError => error
-      raise(error.class, "#{error.message} (mock:#{name}) ")
+## Only need this until we have FakeFS > 0.5.2 that includes this commit.
+## https://github.com/defunkt/fakefs/commit/06eb002da7fb8119a60fef7d50307bd3358c85f3
+module FakeFS
+  class Dir
+    if RUBY_VERSION >= '2.1'
+      module Tmpname # :nodoc:
+        module_function
+
+        def tmpdir
+          Dir.tmpdir
+        end
+
+        def make_tmpname(prefix_suffix, n)
+          case prefix_suffix
+          when String
+            prefix = prefix_suffix
+            suffix = ""
+          when Array
+            prefix = prefix_suffix[0]
+            suffix = prefix_suffix[1]
+          else
+            raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}"
+          end
+          t = Time.now.strftime("%Y%m%d")
+          path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
+          path << "-#{n}" if n
+          path << suffix
+        end
+
+        def create(basename, *rest)
+          if opts = Hash.try_convert(rest[-1])
+            opts = opts.dup if rest.pop.equal?(opts)
+            max_try = opts.delete(:max_try)
+            opts = [opts]
+          else
+            opts = []
+          end
+          tmpdir, = *rest
+          if $SAFE > 0 and tmpdir.tainted?
+            tmpdir = '/tmp'
+          else
+            tmpdir ||= tmpdir()
+          end
+          n = nil
+          begin
+            path = File.join(tmpdir, make_tmpname(basename, n))
+            yield(path, n, *opts)
+          rescue Errno::EEXIST
+            n ||= 0
+            n += 1
+            retry if !max_try or n < max_try
+            raise "cannot generate temporary name using `#{basename}' under `#{tmpdir}'"
+          end
+          path
+        end
+      end
     end
   end
 end
 
-require 'mocha/setup'

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

@@ -1,29 +1,62 @@
 require 'test_helper'
 
 module Minionizer
-  class FileInjectionTest < MiniTest::Unit::TestCase
+  class FileInjectionTest < MiniTest::Test
 
     describe FileInjection do
       let(:session) { 'MockSession' }
-      let(:injection) { FileInjection.new(session) }
-
-      it 'instantiates' do
-        assert_kind_of(FileInjection, injection)
-      end
+      let(:source_path) { 'data/source_file.txt'}
+      let(:target_path) { '/var/target_file.txt'}
+      let(:injection) { FileInjection.new(session, options) }
 
       describe '#call' do
         let(:source_contents) { 'Source Contents' }
-        let(:source) { 'data/source_file.txt'}
-        let(:target) { '/var/target_file.txt'}
 
         before do
-          write_file(source, source_contents)
-          session.expects(:exec).with(%Q{echo '#{source_contents}' > #{target}})
+          write_file(source_path, source_contents)
+          session.expects(:exec).with(%Q{mkdir --parents #{File.dirname(target_path)}})
+          session.expects(:exec).with(%Q{echo '#{source_contents}' > #{target_path}})
+        end
+
+        describe 'only source and target are provided' do
+          let(:options) {{ source_path: source_path, target_path: target_path }}
+
+          it 'sends a command to session' do
+            injection.call
+          end
+
+        end
+
+        describe 'mode is provided' do
+          let(:mode) { '0700' }
+          let(:options) {{ source_path: source_path, target_path: target_path, mode: mode }}
+
+          it 'sets the file permissions' do
+            session.expects(:exec).with(%Q{chmod #{mode} #{target_path}})
+            injection.call
+          end
         end
 
-        it 'sends a command to session' do
-          injection.inject(source, target)
+        describe 'owner is provided' do
+          let(:ownername) { 'otheruser' }
+          let(:options) {{ source_path: source_path, target_path: target_path, owner: ownername }}
+
+          it 'sets the file owner' do
+            session.expects(:exec).with(%Q{chown #{ownername} #{target_path}})
+            injection.call
+          end
         end
+
+        describe 'group is provided' do
+          let(:groupname) { 'othergroup' }
+          let(:options) {{ source_path: source_path, target_path: target_path, group: groupname }}
+
+          it 'sets the file group' do
+            session.expects(:exec).with(%Q{chgrp #{groupname} #{target_path}})
+            injection.call
+          end
+        end
+
       end
 
     end