nodespec 0.1.9 → 0.1.10

data/lib/nodespec/communication_adapters/winrm_communicator.rb

@@ -0,0 +1,65 @@
+require 'nodespec/verbose_output'
+require 'nodespec/runtime_gem_loader'
+require_relative 'remote_backend'
+
+module NodeSpec
+  module CommunicationAdapters
+    class WinrmCommunicator
+      include RemoteBackend
+      include VerboseOutput
+      DEFAULT_PORT = 5985
+      DEFAULT_TRANSPORT = :plaintext
+      DEFAULT_TRANSPORT_OPTIONS = {disable_sspi: true}
+      
+      attr_reader :session, :os
+
+      def initialize(hostname, os = nil, options = {})
+        @os = os
+        @hostname = hostname
+        opts = options.dup
+        port = opts.delete('port') || DEFAULT_PORT
+        @endpoint = "http://#{hostname}:#{port}/wsman"
+
+        if opts.has_key?('transport')
+          @transport = opts.delete('transport').to_sym
+          @options = opts
+        else
+          @transport = DEFAULT_TRANSPORT
+          @options = DEFAULT_TRANSPORT_OPTIONS.merge(opts)
+        end
+        @options = @options.inject({}) {|h,(k,v)| h[k.to_sym] = v; h}
+      end
+
+      def bind_to(configuration)
+        if configuration.ssh
+          close_ssh_session(configuration.ssh)
+          configuration.ssh = nil
+        end
+
+        current_session = configuration.winrm
+        if current_session.nil? || current_session.endpoint != @endpoint
+          current_session = start_winrm_session
+          configuration.winrm = current_session
+          configuration.host = @hostname
+        end
+        @session = current_session
+      end
+
+      private
+
+      def close_ssh_session(session)
+        msg = "\nClosing connection to #{session.host}"
+        msg << ":#{session.options[:port]}" if session.options[:port]
+        verbose_puts msg
+        session.close
+      end
+
+      def start_winrm_session
+        RuntimeGemLoader.require_or_fail('winrm') do
+          verbose_puts "\nConnecting to #{@endpoint}..."
+          WinRM::WinRMWebService.new(@endpoint, @transport, @options)
+        end
+      end
+    end
+  end
+end

data/lib/nodespec/communication_adapters.rb

@@ -0,0 +1,22 @@
+require 'nodespec/communication_adapters/native_communicator'
+
+module NodeSpec
+  module CommunicationAdapters
+    def self.get_communicator(node_name, os = nil, adapter_name = nil, adapter_options = {})
+      if adapter_name
+        require_relative "communication_adapters/#{adapter_name}.rb"
+        clazz = adapter_class(adapter_name)
+        clazz.communicator_for(node_name, os, adapter_options)
+      else
+        NativeCommunicator.new(os)
+      end
+    end
+
+    private
+
+    def self.adapter_class(name)
+      adapter_classname = name.split('_').map(&:capitalize).join('')
+      self.const_get(adapter_classname)
+    end
+  end
+end

data/lib/nodespec/local_command_runner.rb

@@ -0,0 +1,17 @@
+require 'open3'
+require 'nodespec/run_options'
+require 'nodespec/command_execution'
+
+module NodeSpec
+  module LocalCommandRunner
+    include CommandExecution
+
+    def run_command command
+      execute_within_timeout(command) do
+        output, status = Open3.capture2e(command)
+        verbose_puts(output)
+        status.success?
+      end
+    end
+  end
+end

data/lib/nodespec/node.rb

@@ -0,0 +1,56 @@
+require 'specinfra/helper'
+require 'nodespec/communication_adapters'
+require 'nodespec/communication_adapters/native_communicator'
+
+module NodeSpec
+  class Node
+    class BadNodeNameError < StandardError; end
+
+    WORKING_DIR = '.nodespec'
+    attr_reader :os, :communicator, :name
+
+    def initialize(node_name, options = nil)
+      @name = validate(node_name)
+      opts = (options || {}).dup
+      @os = opts.delete('os')
+      adapter_name = opts.delete('adapter')
+      @communicator = CommunicationAdapters.get_communicator(@name, @os, adapter_name, opts)
+    end
+
+    def backend
+      @communicator.backend
+    end
+
+    [:create_directory, :create_file].each do |met|
+      define_method(met) do |*args|
+        path_argument = args.shift
+        unless path_argument.start_with?('/')
+          backend_proxy.create_directory WORKING_DIR
+          path_argument = "#{WORKING_DIR}/#{path_argument}"
+        end
+        backend_proxy.send(met, path_argument, *args)
+        path_argument
+      end
+    end
+
+    def create_temp_directory(path)
+      path = path[1..-1] if path.start_with?('/')
+      create_directory("#{backend_proxy.temp_directory}/#{path}")
+    end
+
+    def execute(command)
+      backend_proxy.execute(command)
+    end
+
+    private
+
+    def backend_proxy
+      @backend_proxy ||= @communicator.backend_proxy
+    end
+
+    def validate(name)
+      raise BadNodeNameError.new unless name =~ /^[a-zA-Z0-9][a-zA-Z0-9. \-_]+\s*$/
+      name.strip.gsub(' ', '-')
+    end
+  end
+end

data/lib/nodespec/node_configurations.rb

@@ -0,0 +1,29 @@
+require 'yaml'
+require 'singleton'
+require_relative 'node'
+
+module NodeSpec
+  class NodeConfigurations
+    include Singleton
+    attr_reader :current_settings
+
+    def initialize
+      filename = ENV['NODESPEC_CONFIG'] || 'nodespec_config.yml'
+      data = YAML.load_file(filename) if File.exists?(filename)
+      @predefined_settings = data || {}
+    end
+
+    def get(node_name, options = nil)
+      case options
+      when String
+        raise "Cannot find nodespec settings '#{options}'" unless @predefined_settings.key?(options)
+        opts = @predefined_settings[options]
+      when Hash
+        opts = options
+      else
+        opts = {}
+      end
+      Node.new(node_name, opts)
+    end
+  end
+end

data/lib/nodespec/provisioning/ansible.rb

@@ -0,0 +1,96 @@
+require 'shellwords'
+require 'tempfile'
+require 'json'
+require 'erb'
+require 'nodespec/local_command_runner'
+
+module NodeSpec
+  module Provisioning
+    class Ansible
+      include LocalCommandRunner
+      CUSTOM_CONFIG_FILENAME = 'nodespec_ansible_cfg'
+      CUSTOM_INVENTORY_FILENAME = 'nodespec_ansible_hosts'
+      AUTO_DISCOVERY_HOST_TEMPLATE = <<-EOS
+<%= "[" + group + "]" if group %>
+<%= @node.name %> ansible_ssh_host=<%= @node.communicator.session.transport.host %> ansible_ssh_port=<%= @node.communicator.session.transport.port %>
+EOS
+
+      def initialize(node)
+        @node = node
+        @sudo_enabled = true
+        @cmd_prefix_entries = []
+        @tmp_files = []
+      end
+
+      def set_config_path(path)
+        @cmd_prefix_entries << "ANSIBLE_CONFIG=#{path.shellescape}"
+      end
+
+      def ansible_config(text)
+        file = create_temp_file(CUSTOM_CONFIG_FILENAME, text)
+        @cmd_prefix_entries << "ANSIBLE_CONFIG=#{file.path.shellescape}"
+      end
+
+      def enable_host_auto_discovery(group = nil)
+        file = create_temp_file(CUSTOM_INVENTORY_FILENAME, ERB.new(AUTO_DISCOVERY_HOST_TEMPLATE).result(binding))
+        @hostfile_option = "-i #{file.path.shellescape}"
+      end
+
+      def set_hostfile_path(path)
+        @hostfile_option = "-i #{path.shellescape}"
+      end
+
+      def set_host_key_checking(enabled)
+        @cmd_prefix_entries << "ANSIBLE_HOST_KEY_CHECKING=#{enabled.to_s.capitalize}"
+      end
+
+      def run_as_sudo(enabled = true)
+        @sudo_enabled = enabled
+      end
+
+      def set_extra_vars(vars = {})
+        @extra_vars_option = "-e '#{JSON.generate(vars)}'"
+      end
+
+      def ansible_playbook(playbook_path, options = [])
+        build_and_run("ansible-playbook #{playbook_path.shellescape} -l #{@node.name}", options)
+      end
+
+      def ansible_module(module_name, module_arguments, options = [])
+        build_and_run("ansible #{@node.name} -m #{module_name} -a #{module_arguments.shellescape}", options)
+      end
+
+      private
+
+      def build_and_run(cmd, options = [])
+        ssh_session = @node.communicator.session
+        key_option = ssh_session.options[:keys].is_a?(Array) ? ssh_session.options[:keys].join(',') : ssh_session.options[:keys]
+        cmd = [
+          (@cmd_prefix_entries.join(' ') unless @cmd_prefix_entries.empty?),
+          cmd,
+          @hostfile_option,
+          "-u #{ssh_session.options[:user]}",
+          "--private-key=#{key_option.shellescape}",
+          sudo_option(ssh_session.options[:user]),
+          "#{options.join(' ')}",
+          @extra_vars_option
+          ].compact.join(' ')
+        
+        run_command(cmd)
+        @tmp_files.each(&:close!)
+      end
+
+      def sudo_option(user)
+        '--sudo' if user != 'root' and @sudo_enabled
+      end
+
+      def create_temp_file(filename, content)
+        Tempfile.new(filename).tap do |f|
+          f.write(content)
+          f.flush
+          @tmp_files << f
+        end
+      end
+    end
+  end
+end

data/lib/nodespec/provisioning/chef.rb

@@ -0,0 +1,68 @@
+require 'shellwords'
+require 'json'
+
+module NodeSpec
+  module Provisioning
+    class Chef
+      CLIENT_CONFIG_FILENAME = 'chef_client.rb'
+      ATTRIBUTES_FILENAME = 'chef_client_attributes.json'
+      NODES_DIRNAME = 'chef_nodes'
+
+      def initialize(node)
+        @node = node
+        @custom_attributes = {}
+        @configuration_entries = []
+      end
+
+      def chef_apply_execute(snippet, options = [])
+        @node.execute("chef-apply #{options.join(' ')} -e #{snippet.shellescape}")
+      end
+
+      def chef_apply_recipe(recipe_file, options = [])
+        @node.execute("chef-apply #{recipe_file.shellescape} #{options.join(' ')}")
+      end
+
+      def set_cookbook_paths(*paths)
+        unless paths.empty?
+          paths_in_quotes = paths.map {|p| "'#{p}'"}
+          @configuration_entries << %Q(cookbook_path [#{paths_in_quotes.join(",")}])
+        end
+      end
+
+      def set_attributes(attributes)
+        @custom_attributes = attributes
+      end
+
+      def chef_client_config(text)
+        @configuration_entries << text
+      end
+
+      def chef_client_runlist(*args)
+        run_list_items, options = [], []
+        run_list_items << args.take_while {|arg| arg.is_a? String}
+        options += args.last if args.last.is_a? Array
+        options << configuration_option
+        options << attributes_option
+        @node.execute("chef-client -z #{options.compact.join(' ')} -o #{run_list_items.join(',').shellescape}")
+      end
+
+      private
+
+      def configuration_option
+        unless @configuration_entries.any? {|c| c =~ /^node_path .+$/}
+          nodes_directory = @node.create_temp_directory(NODES_DIRNAME)
+          @configuration_entries.unshift("node_path '#{nodes_directory}'")
+        end
+        config_file = @node.create_file(CLIENT_CONFIG_FILENAME, @configuration_entries.join("\n"))
+        "-c #{config_file}"
+      end
+
+      def attributes_option
+        unless @custom_attributes.empty?
+          attr_file = @node.create_file(ATTRIBUTES_FILENAME, JSON.generate(@custom_attributes))
+          "-j #{attr_file}"
+        end
+      end
+    end
+  end
+end

data/lib/nodespec/provisioning/puppet.rb

@@ -0,0 +1,55 @@
+require 'yaml'
+require 'shellwords'
+require 'erb'
+
+module NodeSpec
+  module Provisioning
+    class Puppet
+      HIERADATA_DIRNAME = 'puppet_hieradata'
+      HIERA_CONFIG_FILENAME = 'puppet_hiera.yaml'
+      HIERA_DEFAULT_HIERARCHY = 'common'
+      HIERA_CONFIG_TEMPLATE = <<-EOS
+:backends:
+  - yaml
+:yaml:
+  :datadir: <%= hieradata_dir %>
+:hierarchy:
+  - #{HIERA_DEFAULT_HIERARCHY}
+EOS
+      def initialize(node)
+        @node = node
+      end
+
+      def set_modulepaths(*paths)
+        @modulepath_option = "--modulepath #{paths.join(':').shellescape}" unless paths.empty?
+      end
+
+      def set_facts(facts)
+        @facts = facts.reduce("") { |fact, pair| "FACTER_#{pair[0]}=#{pair[1].shellescape} #{fact}" }
+      end
+
+      def set_hieradata(values)
+        unless values.empty?
+          hieradata_dir = @node.create_directory(HIERADATA_DIRNAME)
+          @node.create_file("#{HIERADATA_DIRNAME}/#{HIERA_DEFAULT_HIERARCHY}.yaml", YAML.dump(values))
+          hiera_config = @node.create_file(HIERA_CONFIG_FILENAME, ERB.new(HIERA_CONFIG_TEMPLATE).result(binding))
+          @hiera_option = "--hiera_config #{hiera_config}"
+        end
+      end
+
+      def puppet_apply_execute(snippet, options = [])
+        @node.execute("#{group_command_options(options)} -e #{snippet.shellescape}")
+      end
+
+      def puppet_apply_manifest(manifest_file, options = [])
+        @node.execute("#{group_command_options(options)} #{manifest_file.shellescape}")
+      end
+
+      private
+
+      def group_command_options(options)
+        %Q[#{@facts}puppet apply #{@modulepath_option} #{@hiera_option} #{options.join(' ')}]
+      end
+    end
+  end
+end

data/lib/nodespec/provisioning/shellscript.rb

@@ -0,0 +1,19 @@
+require 'shellwords'
+
+module NodeSpec
+  module Provisioning
+    class Shellscript
+      def initialize(node)
+        @node = node
+      end
+
+      def execute_file(path)
+        @node.execute(path)
+      end
+
+      def execute_script(script)
+        @node.execute("sh -c #{script.shellescape}")
+      end
+    end
+  end
+end

data/lib/nodespec/provisioning.rb

@@ -0,0 +1,14 @@
+Dir[File.join(File.dirname(__FILE__), 'provisioning/*.rb')].each {|f| require f}
+
+module NodeSpec
+  module Provisioning
+    self.constants.each do |provisioner_name|
+      provisioner_class = self.const_get(provisioner_name)
+      define_method("provision_node_with_#{provisioner_name.downcase}".to_sym) do |&block|
+        @provisioners ||= {}
+        @provisioners[provisioner_name.downcase] = provisioner_class.new(NodeSpec.current_node) unless @provisioners.key?(provisioner_name.downcase)
+        @provisioners[provisioner_name.downcase].instance_eval(&block)
+      end
+    end
+  end
+end

data/lib/nodespec/run_options.rb

@@ -0,0 +1,14 @@
+module NodeSpec
+  module RunOptions
+    class << self
+      [:verbose, :run_local_with_sudo].each do |attr|
+        attr_accessor attr
+        alias_method("#{attr}?".to_sym, attr)
+      end
+      attr_writer :command_timeout
+      def command_timeout
+        @command_timeout || 600
+      end
+    end
+  end
+end

data/lib/nodespec/runtime_gem_loader.rb

@@ -0,0 +1,19 @@
+module NodeSpec
+  module RuntimeGemLoader
+    DEFAULT_ERROR_MSG = 'Consider installing the missing gem'
+    def self.require_or_fail(gem_name, error_message = nil)
+      begin
+        require gem_name
+          yield if block_given?
+      rescue LoadError => e
+        err = <<-EOS
+Error: #{e.message}
+#{error_message || DEFAULT_ERROR_MSG}
+
+gem install '#{gem_name}'
+EOS
+        fail(err)
+        end
+      end
+  end
+end

data/lib/nodespec/shared_examples_support.rb

@@ -0,0 +1,13 @@
+require 'rspec'
+module NodeSpec
+  module SharedExamplesSupport
+    def it_is_node_with_roles *instance_roles
+      instance_roles.each {|role| it_behaves_like role}
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.alias_it_behaves_like_to :it_is_node_configured_with, 'is a node configured with:'
+  config.extend NodeSpec::SharedExamplesSupport
+end

data/lib/nodespec/verbose_output.rb

@@ -0,0 +1,9 @@
+require_relative 'run_options'
+
+module NodeSpec
+  module VerboseOutput
+    def verbose_puts(msg)
+      puts msg if NodeSpec::RunOptions.verbose?
+    end
+  end
+end

data/lib/nodespec/version.rb

@@ -0,0 +1,3 @@
+module NodeSpec
+  VERSION = '0.1.10'
+end

data/nodespec.gemspec

@@ -0,0 +1,28 @@
+libdir = File.join(File.dirname(__FILE__), 'lib')
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+require 'nodespec/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'nodespec'
+  gem.version       = NodeSpec::VERSION
+  gem.summary       = 'RSpec style tests for multiple nodes/server instances with support for provisioning instructions'
+  gem.description   = 'RSpec style tests for multiple nodes/server instances with support for provisioning instructions'
+  
+  gem.authors       = ['Silvio Montanari']
+  gem.homepage      = 'https://github.com/smontanari/nodespec'
+  gem.files         = `git ls-files`.split($/)
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.require_paths = ['lib']
+
+  gem.required_ruby_version = '>= 1.9.3'
+
+  gem.add_runtime_dependency 'net-ssh'
+  gem.add_runtime_dependency 'serverspec'
+  gem.add_runtime_dependency 'specinfra', '>= 1.18.4'
+  gem.add_development_dependency 'rspec', '~> 3.0'
+  gem.add_development_dependency 'aws-sdk'
+  gem.add_development_dependency 'winrm'
+  gem.add_development_dependency 'bundler'
+  gem.add_development_dependency 'rake'
+end

data/spec/backend_proxy/base_spec.rb

@@ -0,0 +1,29 @@
+require 'nodespec/backend_proxy/base'
+
+module NodeSpec
+  module BackendProxy
+    describe Base do
+      describe '#create_file' do
+        it 'executes the generated command' do
+          allow(subject).to receive(:cmd_create_file).with('test/path', 'test content').and_return('command')
+          expect(subject).to receive(:execute).with('command')
+
+          subject.create_file('test/path', 'test content')
+        end
+      end
+
+      describe '#create_directory' do
+        it 'executes the generated command' do
+          allow(subject).to receive(:cmd_create_directory).with('test/path').and_return('command')
+          expect(subject).to receive(:execute).with('command')
+
+          subject.create_directory('test/path')
+        end
+      end
+
+      it 'behaves like a command execution' do
+        expect(subject).to respond_to(:execute_within_timeout)
+      end
+    end
+  end
+end

data/spec/backend_proxy/exec_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'nodespec/backend_proxy/exec'
+
+module NodeSpec
+  module BackendProxy
+    describe Exec do
+      shared_examples 'a command run' do |original_command, actual_command, sudo_option|
+        let(:cmd_status) { double('status') }
+
+        before do
+          NodeSpec::RunOptions.run_local_with_sudo = sudo_option
+          allow(Open3).to receive(:capture2e).with(actual_command).and_return(['test output', cmd_status])
+          allow(subject).to receive(:execute_within_timeout).with(actual_command).and_yield
+        end
+
+        
+        it 'returns true if the command succeeds' do
+          allow(cmd_status).to receive(:success?).and_return(true)
+          
+          expect(subject.execute(original_command)).to be_truthy
+        end
+
+        it 'returns false if the command fails' do
+          allow(cmd_status).to receive(:success?).and_return(false)
+          
+          expect(subject.execute(original_command)).to be_falsy
+        end
+      end
+      
+      it_behaves_like 'a command run', 'test command', 'test command', false
+      it_behaves_like 'a command run', 'test command', 'sudo test command', true
+    end
+  end
+end

data/spec/backend_proxy/ssh_spec.rb

@@ -0,0 +1,32 @@
+require 'nodespec/backend_proxy/ssh'
+
+module NodeSpec
+  module BackendProxy
+    describe Ssh do
+      let(:ssh_session) { double('ssh session') }
+      let(:subject) {Ssh.new(ssh_session)}
+
+      shared_examples 'an ssh session command run' do |user, original_command, actual_command|
+        before do
+          allow(ssh_session).to receive(:options).and_return({user: user})
+          allow(subject).to receive(:execute_within_timeout).with(actual_command).and_yield
+        end
+        
+        it 'returns true if the command succeeds' do
+          allow(ssh_session).to receive(:exec!).with(actual_command).and_yield(nil, 'a stream', 'test data')
+          
+          expect(subject.execute(original_command)).to be_truthy
+        end
+
+        it 'returns false if the command fails' do
+          allow(ssh_session).to receive(:exec!).with(actual_command).and_yield(nil, :stderr, 'test data')
+          
+          expect(subject.execute(original_command)).to be_falsy
+        end
+      end
+      
+      it_behaves_like 'an ssh session command run', 'root', 'test command', 'test command'
+      it_behaves_like 'an ssh session command run', 'some_user', 'test command', 'sudo test command'
+    end
+  end
+end

data/spec/backend_proxy/unixshell_utility_spec.rb

@@ -0,0 +1,29 @@
+require 'nodespec/backend_proxy/unixshell_utility'
+
+module NodeSpec
+  module BackendProxy
+    describe UnixshellUtility do
+      let(:subject) {Object.new.extend UnixshellUtility}
+
+      it 'returns the command as run by sudo' do
+        expect(subject.run_as_sudo('command')).to eq 'sudo command'
+      end
+
+      it 'returns the command to create a directory' do
+        expect(subject.cmd_create_directory('/path to/dir')).to eq('sh -c "mkdir -p /path\ to/dir"')
+      end
+
+      it 'returns the path to the temp directory' do
+        expect(subject.temp_directory).to eq('/tmp')
+      end
+
+      it 'writes the given content to a file' do
+        content = <<-eos
+some 'text'
+some "other" text
+eos
+        expect(subject.cmd_create_file('/path to/file', content)).to eq %Q[sh -c "cat > /path\\ to/file << EOF\nsome 'text'\nsome \\"other\\" text\nEOF"]
+      end
+    end
+  end
+end