RubyGems - serverspec-extended-types - Versions diffs - 0.0.1 - Mend

serverspec-extended-types 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

checksums.yaml +15 -0
data/.gitignore +22 -0
data/.rspec +2 -0
data/.travis.yml +13 -0
data/.yardopts +1 -0
data/CHANGES.md +5 -0
data/Gemfile +4 -0
data/LICENSE.txt +22 -0
data/README.md +249 -0
data/Rakefile +53 -0
data/lib/serverspec_extended_types.rb +4 -0
data/lib/serverspec_extended_types/bitlbee.rb +204 -0
data/lib/serverspec_extended_types/http_get.rb +159 -0
data/lib/serverspec_extended_types/version.rb +3 -0
data/lib/serverspec_extended_types/virtualenv.rb +161 -0
data/serverspec-extended-types.gemspec +31 -0
data/spec/spec_helper.rb +42 -0
data/spec/types/bitlbee_spec.rb +189 -0
data/spec/types/http_get_spec.rb +75 -0
data/spec/types/virtualenv_spec.rb +201 -0
metadata +223 -0

data/lib/serverspec_extended_types/http_get.rb ADDED

@@ -0,0 +1,159 @@
+##############################################################################
+# serverspec-extended-types - http_get
+#
+# <https://github.com/jantman/serverspec-extended-types>
+#
+# Copyright (C) 2015 Jason Antman <jason@jasonantman.com>
+#
+# Licensed under the MIT License - see LICENSE.txt
+#
+##############################################################################
+require 'timeout'
+require 'faraday'
+require 'serverspec_extended_types/version'
+module Serverspec
+  module Type
+    # Perform an HTTP GET request against the serverspec target
+    # using {http://www.rubydoc.info/gems/faraday/ Faraday}.
+    class Http_Get < Base
+      # Initialize a bunch of instance variables, then call {#getpage}
+      #
+      # Calls {#getpage} within a {Timeout::timeout} block;
+      # If {#getpage} times out, set ``timed_out_status`` to [True]
+      #
+      # @param port [Int] the port to connect to HTTP over
+      # @param host_header [String] the value to set in the 'Host' HTTP request header
+      # @param path [String] the URI/path to request from the server
+      # @param timeout_sec [Int] how many seconds to allow request to run before timing out and setting @timed_out_status to True
+      #
+      # @example
+      #   describe http_get(80, 'myhostname', '/') do
+      #     # tests here
+      #   end
+      #
+      # @api public
+      # @return [nil]
+      def initialize(port, host_header, path, timeout_sec=10)
+        @ip = ENV['TARGET_HOST']
+        @port = port
+        @host = host_header
+        @path = path
+        @timed_out_status = false
+        @content_str = nil
+        @headers_hash = nil
+        @response_code_int = nil
+        begin
+          Timeout::timeout(timeout_sec) do
+            getpage
+          end
+        rescue Timeout::Error
+          @timed_out_status = true
+        end
+      end
+      # Private method to actually get the page; must be called within a timeout block
+      #
+      # Gets the page using {http://www.rubydoc.info/gems/faraday/ Faraday} and then sets instance variables for the various attribute readers.
+      #
+      # @api private
+      # @return [nil]
+      def getpage
+        ip = @ip
+        port = @port
+        conn = Faraday.new("http://#{ip}:#{port}/")
+        version = ServerspecExtendedTypes::VERSION
+        conn.headers[:user_agent] = "Serverspec::Type::Http_Get/#{version} (https://github.com/jantman/serverspec-extended-types)"
+        conn.headers[:Host] = @host
+        response = conn.get(@path)
+        @response_code_int = response.status
+        @content_str = response.body
+        @headers_hash = Hash.new('')
+        response.headers.each do |header, val|
+          @headers_hash[header] = val
+        end
+      end
+      # Whether or not the request timed out
+      #
+      # @example
+      #   describe http_get(80, 'myhostname', '/') do
+      #     it { should_not be_timed_out }
+      #   end
+      #
+      # @api public
+      # @return [Boolean]
+      def timed_out?
+        @timed_out_status
+      end
+      # Returns the HTTP response headers as a hash
+      #
+      # @example
+      #   describe http_get(80, 'myhostname', '/') do
+      #     its(:headers) { should include('HeaderName' => /value regex/) }
+      #   end
+      #
+      # @api public
+      # @return [Hash]
+      def headers
+        @headers_hash
+      end
+      # Returns the HTTP status code, or 0 if timed out
+      #
+      # @example
+      #   describe http_get(80, 'myhostname', '/') do
+      #     its(:status) { should eq 200 }
+      #   end
+      #
+      # @api public
+      # @return [Int]
+      def status
+        if @timed_out_status
+          0
+        else
+          @response_code_int
+        end
+      end
+      # Returns the body/content of the HTTP response
+      #
+      # @example
+      #   describe http_get(80, 'myhostname', '/') do
+      #     its(:body) { should match /<html>/ }
+      #   end
+      #
+      # @api public
+      # @return [String]
+      def body
+        @content_str
+      end
+      private :getpage
+    end
+    # ServerSpec Type wrapper for http_get
+    #
+    # @example
+    #   describe http_get(80, 'myhostname', '/') do
+    #     # tests here
+    #   end
+    #
+    # @param port [Int] the port to connect to HTTP over
+    # @param host_header [String] the value to set in the 'Host' HTTP request header
+    # @param path [String] the URI/path to request from the server
+    # @param timeout_sec [Int] how many seconds to allow request to run before timing out and setting @timed_out_status to True
+    #
+    # @api public
+    # @return [Serverspec::Type::Http_Get]
+    def http_get(port, host_header, path, timeout_sec=10)
+      Http_Get.new(port, host_header, path, timeout_sec=timeout_sec)
+    end
+  end
+end
+include Serverspec::Type

data/lib/serverspec_extended_types/version.rb ADDED

@@ -0,0 +1,3 @@
+module ServerspecExtendedTypes
+  VERSION = "0.0.1"
+end

data/lib/serverspec_extended_types/virtualenv.rb ADDED

@@ -0,0 +1,161 @@
+##############################################################################
+# serverspec-extended-types - virtualenv
+#
+# <https://github.com/jantman/serverspec-extended-types>
+#
+# Copyright (C) 2015 Jason Antman <jason@jasonantman.com>
+#
+# Licensed under the MIT License - see LICENSE.txt
+#
+##############################################################################
+module Serverspec::Type
+  class Virtualenv < Base
+    # Test whether this appears to be a working venv
+    #
+    # Tests performed:
+    # - venv_path/bin/pip executable by root?
+    # - venv_path/bin/python executable by root?
+    # - venv_path/bin/activate executable by root?
+    # - 'export VIRTUAL_ENV' in venv_path/bin/activate?
+    #
+    # @example
+    #   describe virtualenv('/path/to/venv') do
+    #     it { should be_virtualenv }
+    #   end
+    #
+    # @api public
+    # @return [Boolean]
+    def virtualenv?
+      pip_path = ::File.join(@name, 'bin', 'pip')
+      python_path = ::File.join(@name, 'bin', 'python')
+      act_path = ::File.join(@name, 'bin', 'activate')
+      cmd = "grep -q 'export VIRTUAL_ENV' #{act_path}"
+      @runner.check_file_is_executable(pip_path, 'root') and
+        @runner.check_file_is_executable(python_path, 'root') and
+        @runner.check_file_is_executable(act_path, 'root') and
+        @runner.run_command(cmd).exit_status.to_i == 0
+    end
+    # Return the version of pip installed in the virtualenv
+    #
+    # @example
+    #   describe virtualenv('/path/to/venv') do
+    #     its(:pip_version) { should match /^6\.0\.6$/ }
+    #   end
+    #
+    # @api public
+    # @return [String]
+    def pip_version
+      @pip_version || get_pip_version
+    end
+    # Return the version of python installed in the virtualenv
+    #
+    # @example
+    #   describe virtualenv('/path/to/venv') do
+    #     its(:python_version) { should match /^2\.7\.9$/ }
+    #   end
+    #
+    # @api public
+    # @return [String]
+    def python_version
+      @python_version || get_python_version
+    end
+    # Return a hash of all packages present in `pip freeze` output for the venv
+    #
+    # Note that any editable packages (`-e something`) are returned as hash keys
+    # with an empty value
+    #
+    # @example
+    #   describe virtualenv('/path/to/venv') do
+    #     its(:pip_freeze) { should include('wsgiref' => '0.1.2') }
+    #     its(:pip_freeze) { should include('requests') }
+    #     its(:pip_freeze) { should include('pytest' => /^2\.6/) }
+    #     its(:pip_freeze) { should include('-e git+git@github.com:jantman/someproject.git@1d8a380e3af9d081081d7ef685979200a7db4130#egg=someproject') }
+    #   end
+    #
+    # @api public
+    # @return [Hash]
+    def pip_freeze
+      @pip_freeze || get_pip_freeze
+    end
+    private
+    # Get a hash for the `pip freeze` output; set @pip_freeze
+    #
+    # @api private
+    # @return [nil]
+    def get_pip_freeze()
+      pip_path = ::File.join(@name, 'bin', 'pip')
+      tmp = @runner.run_command("#{pip_path} freeze")
+      @pip_freeze = Hash.new()
+      if tmp.exit_status.to_i != 0
+        return @pip_freeze
+      end
+      lines = tmp.stdout.split("\n")
+      lines.each do |line|
+        line.strip!
+        if line =~ /^-e /
+          @pip_freeze[line] = ''
+          next
+        end
+        parts = line.split(/==/)
+        @pip_freeze[parts[0]] = parts[1]
+      end
+      @pip_freeze
+    end
+    private
+    # Get the pip version from the venv; set @pip_version
+    #
+    # @api private
+    # @return [nil]
+    def get_pip_version()
+      pip_path = ::File.join(@name, 'bin', 'pip')
+      pip_path = ::File.join(@name, 'bin', 'pip')
+      tmp = @runner.run_command("#{pip_path} --version")
+      if ( tmp.stdout =~ /^pip (\d+\S+)/ )
+        @pip_version = $1
+      else
+        @pip_version = ''
+      end
+    end
+    private
+    # Get the python version from the venv; set @python_version
+    #
+    # @api private
+    # @return [nil]
+    def get_python_version()
+      python_path = ::File.join(@name, 'bin', 'python')
+      tmp = @runner.run_command("#{python_path} --version")
+      if ( tmp.stderr =~ /^[Pp]ython (\d+\S+)/ )
+        @python_version = $1
+      elsif ( tmp.stdout =~ /^[Pp]ython (\d+\S+)/ )
+        @python_version = $1
+      else
+        @python_version = ''
+      end
+    end
+  end
+  # Serverspec Type wrapper method for Serverspec::Type::Virtualenv
+  #
+  # @example
+  #   describe virtualenv('/path/to/venv') do
+  #     # tests here
+  #   end
+  #
+  # @param name [String] the absolute path to the virtualenv root
+  #
+  # @api public
+  # @return {Serverspec::Type::Virtualenv}
+  def virtualenv(name)
+    Virtualenv.new(name)
+  end
+end
+include Serverspec::Type

data/serverspec-extended-types.gemspec ADDED

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'serverspec_extended_types/version'
+Gem::Specification.new do |spec|
+  spec.name          = "serverspec-extended-types"
+  spec.version       = ServerspecExtendedTypes::VERSION
+  spec.authors       = ["Jason Antman"]
+  spec.email         = ["jason@jasonantman.com"]
+  spec.summary       = %q{A set of extended types for ServerSpec 2.x}
+  spec.description   = %q{This gem provides some purpose-specific types for ServerSpec 2.x beyond the default ones. It is in no way associated with the ServerSpec project or developers.}
+  spec.homepage      = "https://github.com/jantman/serverspec-extended-types"
+  spec.license       = "MIT"
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_dependency "serverspec", "~> 2"
+  spec.add_dependency "specinfra", "~> 2"
+  spec.add_dependency 'rspec', '>= 3.0'
+  spec.add_dependency 'faraday'
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'codecov'
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'yardstick'
+  spec.add_development_dependency 'redcarpet'
+end

data/spec/spec_helper.rb ADDED

@@ -0,0 +1,42 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/vendor/"
+end
+require 'codecov'
+if ENV['CI']=='true'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+require 'specinfra'
+require 'rspec/mocks/standalone'
+require 'rspec/its'
+require 'specinfra/helper/set'
+include Specinfra::Helper::Set
+set :backend, :exec
+set :os, :family => 'linux'
+module Specinfra
+  module Backend
+    class Ssh
+      def run_command(cmd, opts={})
+        CommandResult.new :stdout => nil, :exit_status => 0
+      end
+    end
+  end
+end
+module GetCommand
+  def get_command(method, *args)
+    Specinfra.command.get(method, *args)
+  end
+end
+include GetCommand
+require 'serverspec_extended_types'

data/spec/types/bitlbee_spec.rb ADDED

@@ -0,0 +1,189 @@
+require 'spec_helper'
+require 'serverspec_extended_types/http_get'
+describe 'Serverspec::Type.bitlbee' do
+  it 'instantiates the class with the correct parameters' do
+    expect(Serverspec::Type::Bitlbee).to receive(:new).with(1, 'mynick', 'mypass', false)
+    bitlbee(1, 'mynick', 'mypass')
+  end
+  it 'returns the new object' do
+    expect(Serverspec::Type::Bitlbee).to receive(:new).and_return("foo")
+    expect(bitlbee(1, 'foo', 'bar')).to eq "foo"
+  end
+end
+describe 'Serverspec::Type::Bitlbee' do
+  context '#initialize' do
+    it 'sets instance variables' do
+      stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'myhost'))
+      x = bitlbee(1, 'foo', 'bar')
+      expect(x.instance_variable_get(:@port)).to eq 1
+      expect(x.instance_variable_get(:@host)).to eq 'myhost'
+      expect(x.instance_variable_get(:@nick)).to eq 'foo'
+      expect(x.instance_variable_get(:@password)).to eq 'bar'
+      expect(x.instance_variable_get(:@connected_status)).to eq false
+      expect(x.instance_variable_get(:@version_str)).to eq ''
+      expect(x.instance_variable_get(:@timed_out_status)).to eq false
+      expect(x.instance_variable_get(:@started)).to eq false
+      expect(x.instance_variable_get(:@use_ssl)).to eq false
+    end
+    it 'sets use_ssl instance variable' do
+      stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'myhost'))
+      x = bitlbee(1, 'foo', 'bar', use_ssl=true)
+      expect(x.instance_variable_get(:@use_ssl)).to eq true
+    end
+  end
+  context 'start' do
+    it 'calls connect_ssl if use_ssl=true' do
+      x = bitlbee(1, 'foo', 'bar', use_ssl=true)
+      expect(x).to receive(:connect_ssl).once
+      expect(x).to_not receive(:connect)
+      x.start
+      expect(x.instance_variable_get(:@timed_out_status)).to eq false
+      expect(x.instance_variable_get(:@connected_status)).to eq false
+      expect(x.instance_variable_get(:@started)).to eq true
+    end
+    it 'calls connect if use_ssl=false' do
+      x = bitlbee(1, 'foo', 'bar')
+      expect(x).to receive(:connect).once
+      expect(x).to_not receive(:connect_ssl)
+      x.start
+      expect(x.instance_variable_get(:@timed_out_status)).to eq false
+      expect(x.instance_variable_get(:@connected_status)).to eq false
+      expect(x.instance_variable_get(:@started)).to eq true
+    end
+    it 'runs with a timeout' do
+      x = bitlbee(1, 'foo', 'bar')
+      expect(Timeout).to receive(:timeout).with(10)
+      x.start
+      expect(x.instance_variable_get(:@timed_out_status)).to eq false
+      expect(x.instance_variable_get(:@connected_status)).to eq false
+      expect(x.instance_variable_get(:@started)).to eq true
+      expect(x.timed_out?).to eq false
+    end
+    it 'sets timed_out_status on timeout' do
+      x = bitlbee(1, 'foo', 'bar')
+      expect(Timeout).to receive(:timeout).with(10).and_raise(Timeout::Error)
+      x.start
+      expect(x.instance_variable_get(:@timed_out_status)).to eq true
+      expect(x.instance_variable_get(:@connected_status)).to eq false
+      expect(x.instance_variable_get(:@started)).to eq true
+      expect(x.timed_out?).to eq true
+      expect(x.connectable?).to eq false
+    end
+    it 'sets connected_status on ECONNREFUSED' do
+      x = bitlbee(1, 'foo', 'bar')
+      expect(x).to receive(:connect).and_raise(Errno::ECONNREFUSED)
+      x.start
+      expect(x.instance_variable_get(:@timed_out_status)).to eq false
+      expect(x.instance_variable_get(:@connected_status)).to eq false
+      expect(x.instance_variable_get(:@started)).to eq true
+      expect(x.timed_out?).to eq false
+      expect(x.connectable?).to eq false
+    end
+  end
+  context '#connect_ssl' do
+    it 'calls communicate' do
+      stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'myhost'))
+      sock_dbl = double
+      expect(TCPSocket).to receive(:open).with('myhost', 1).and_return(sock_dbl)
+      sslctx_dbl = double
+      expect(OpenSSL::SSL::SSLContext).to receive(:new).and_return(sslctx_dbl)
+      expect(sslctx_dbl).to receive(:set_params).with(verify_mode: OpenSSL::SSL::VERIFY_NONE).ordered
+      sslsock_dbl = double
+      expect(sslsock_dbl).to receive(:sync_close=).ordered.with(true)
+      expect(sslsock_dbl).to receive(:connect).ordered
+      expect(sslsock_dbl).to receive(:puts).ordered.with("communicate")
+      expect(sslsock_dbl).to receive(:puts).ordered.with("QUIT :\"outta here\"\n")
+      expect(sslsock_dbl).to receive(:close).ordered
+      expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(sock_dbl, sslctx_dbl).and_return(sslsock_dbl)
+      #expect_any_instance_of(Serverspec::Type::Bitlbee).to receive(:communicate)
+      x = bitlbee(1, 'foo', 'bar')
+      x.stub(:communicate) do
+        x.instance_variable_get(:@socket).puts("communicate")
+      end
+      x.connect_ssl
+      expect(x.instance_variable_get(:@socket)).to eq sslsock_dbl
+    end
+  end
+  context '#connect' do
+    it 'calls communicate' do
+      stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'myhost'))
+      sock_dbl = double
+      expect(TCPSocket).to receive(:open).with('myhost', 1).and_return(sock_dbl)
+      expect(sock_dbl).to receive(:puts).ordered.with("communicate")
+      expect(sock_dbl).to receive(:puts).ordered.with("QUIT :\"outta here\"\n")
+      expect(sock_dbl).to receive(:close).ordered
+      x = bitlbee(1, 'foo', 'bar')
+      x.stub(:communicate) do
+        x.instance_variable_get(:@socket).puts("communicate")
+      end
+      x.connect
+      expect(x.instance_variable_get(:@socket)).to eq sock_dbl
+    end
+  end
+  context '#communicate' do
+    it 'logs in' do
+      x = bitlbee(1, 'foo', 'bar')
+      sock = double
+      x.instance_variable_set(:@socket, sock)
+      x.instance_variable_set(:@started, true)
+      expect(sock).to receive(:puts).ordered.with("PASS bar\n")
+      expect(sock).to receive(:puts).ordered.with("NICK foo\n")
+      expect(sock).to receive(:puts).ordered.with("USER foo foo servername :TestUser\n")
+      expect(sock).to receive(:readpartial).ordered.with(1024).and_return("Welcome to the foo")
+      expect(sock).to receive(:puts).ordered.with("MODE foo +i\n")
+      expect(sock).to receive(:readpartial).ordered.with(1024).and_return("If you've never something something")
+      expect(sock).to receive(:puts).ordered.with("PRIVMSG &bitlbee :identify bar\n")
+      expect(sock).to receive(:readpartial).ordered.with(1024).and_return("PING servername")
+      expect(sock).to receive(:puts).ordered.with(":servername PONG servername :servername\n")
+      expect(sock).to receive(:readpartial).ordered.with(1024).and_return("MODE foo :\+i")
+      expect(sock).to receive(:puts).ordered.with("PRIVMSG root :\001VERSION\001\n")
+      expect(sock).to receive(:readpartial).ordered.with(1024).and_return("foo bar baz blam\n")
+      expect(sock).to receive(:readpartial).ordered.with(1024).and_return("VERSION x.y.z\n")
+      x.communicate
+      expect(x.instance_variable_get(:@connected_status)).to eq true
+      expect(x.version).to eq 'x.y.z'
+      expect(x.connectable?).to eq true
+      expect(x.timed_out?).to eq false
+    end
+  end
+  context '#timed_out?' do
+    it 'calls start if not started' do
+      x = bitlbee(1, 'foo', 'bar')
+      expect(x).to receive(:start).once
+      expect(x.timed_out?).to eq false
+    end
+    it 'doesnt call start if started' do
+      x = bitlbee(1, 'foo', 'bar')
+      x.instance_variable_set(:@started, true)
+      expect(x).to_not receive(:start)
+      expect(x.timed_out?).to eq false
+    end
+  end
+  context '#connectable?' do
+    it 'calls start if not started' do
+      x = bitlbee(1, 'foo', 'bar')
+      expect(x).to receive(:start).once
+      expect(x.connectable?).to eq false
+    end
+    it 'doesnt call start if started' do
+      x = bitlbee(1, 'foo', 'bar')
+      x.instance_variable_set(:@started, true)
+      expect(x).to_not receive(:start)
+      expect(x.connectable?).to eq false
+    end
+  end
+  context '#version?' do
+    it 'calls start if not started' do
+      x = bitlbee(1, 'foo', 'bar')
+      expect(x).to receive(:start).once
+      expect(x.version).to eq ""
+    end
+    it 'doesnt call start if started' do
+      x = bitlbee(1, 'foo', 'bar')
+      x.instance_variable_set(:@started, true)
+      expect(x).to_not receive(:start)
+      expect(x.version).to eq ""
+    end
+  end
+end