testbeat 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a07df1c8d2decd193451ed6563c37ecf5d77e4e6
+  data.tar.gz: efc84e08c072861996aca8d767fe7195da3e87d0
+SHA512:
+  metadata.gz: 90f7258973368c942e722f6b1be18804ca132da3e05d5da189ac339f49705b7cb191ceb2268cdb65567a131578e8f7204085ab73bc91727754724384abea11e7
+  data.tar.gz: fc8a054528bedcbc506d183138d5414fdcd1d30dd69ef73dd900b6000f305e5fde425a04838d8b36dae9b1c68d169026638f601bdbc13905648637410959befb

data/lib/spec_helper.rb

@@ -0,0 +1,479 @@
+
+require "awesome_print"
+require "net/http"
+require "openssl"
+require "json"
+require "hashie"
+require "logger"
+
+# TODO can we support http://www.relishapp.com/rspec/rspec-core/v/3-1/docs/example-groups/shared-context
+
+# Node should have getters for repository and hosting specifics
+# Configuration attributes for the node should are available as [:properties]
+
+# global so we don't need to pass this around to utility classes
+$logger = Logger.new('testbeat-debug.log')
+
+class TestbeatNode
+
+  def initialize(nodename)
+    @name = nodename
+    if !@name || @name.length == 0
+      logger.error { "Node name not set, at #{Dir.pwd}" }
+      raise "Node name not set"
+    end
+    attributesFile = "#{folder}/chef.json"
+    if File.exists?(attributesFile)
+      @attributes = read_chef_attributes(attributesFile)
+    else
+      logger.warn { "Failed to locate node attributes, from #{attributesFile}, at #{Dir.pwd}" }
+      @attributes = nil
+    end
+    logger.info { "Node initialized #{nodename}, attributes from #{attributesFile}" }
+  end
+
+  def logger
+    $logger
+  end
+
+  def folder
+    "nodes/#{@name}"
+  end
+
+  def vagrant?
+    vagrantfile = "#{folder}/Vagrantfile"
+    return File.exists?(vagrantfile)
+  end
+
+  # Attributes defined specifically on the node, not aggregated like in chef runs
+  def attributes
+    @attributes
+  end
+
+  def attributes?
+    @attributes != nil
+  end
+
+  # Provides access to attributes, if available, as @node[key] much like in chef cookbooks
+  # Use .keys to see if a key exists
+  def [](key)
+    return nil if @attributes == nil
+    # Raise exception so test issues are clearly displayed in rspec output (puts is displayed before test output, difficult to identify which test it comes from)
+    raise "Missing attribute key '#{key}', got #{@attributes.keys}" if not @attributes.key?(key)
+    @attributes[key]
+  end
+
+  # More methods to work like hash
+  def keys
+    @attributes.keys
+  end
+
+  def key?(key)
+    @attributes.key?(key)
+  end
+
+  # host is assumed to be equivalent with node name now, but we could read it from attributes, see ticket:1017
+  def host
+    @name
+  end
+
+  # returns hash "username" and "password", or false if unsupported
+  def testauth
+    return false # we don't support authenticated nodes yet
+  end
+
+  # return command line access, instance of TestbeatNodeRsh, or false if unsupported
+  # This is probably easier to support than get_bats; on vagrant nodes we have 'vagrant ssh -c'
+  def shell
+    if not vagrant?
+      return TestbeatShellStub.new()
+    end
+    return TestbeatShellVagrant.new(folder)
+  end
+
+  def provision
+    if not vagrant?
+      raise "Provision support will probably require a vagrant box"
+    else
+      raise "Provision not implemented"
+    end
+  end
+
+
+  def to_s
+    "Testbeat node #{@name}"
+    #ap @attributes
+  end
+
+  # The following methods are private
+  private
+
+  # Returns node attributes from node file compatible with "knife node from file"
+  # Returns as Mash because that's what chef uses
+  def read_chef_attributes(jsonPath)
+    #p "read attributes from #{jsonPath}"
+    data = nil
+    File::open(jsonPath) { |f|
+      data = f.read
+    }
+    raise "Failed to read file #{jsonPath}" if data == nil
+    json = JSON.parse(data)
+    mash = Hashie::Mash.new(json)
+    raise "Missing 'normal' attributes in node file #{jsonPath}" if not mash.key?("normal")
+    return mash["normal"]
+  end
+
+end
+
+# Support different types of command execution on node
+class TestbeatShell
+
+  def exec(cmd)
+    raise "Command execution on this node is not supported"
+  end
+
+end
+
+class TestbeatShellVagrant
+
+  def initialize(vagrantFolder)
+    @vagrantFolder = vagrantFolder
+  end
+
+  def exec(cmd)
+    $logger.debug {"Exec: #{cmd}"}
+    stdout = nil
+    Dir.chdir(@vagrantFolder){
+      @out = %x[vagrant ssh -c '#{cmd}' 2>&1]
+      @status = $?
+    }
+    $logger.debug {"Exec result #{exitstatus}: #{@out[0,50].strip}"}
+    return self
+  end
+
+  # output of latest exec (stdout and stderr merged, as we haven't worked on separating them)
+  def out
+    @out
+  end
+
+  def exitstatus
+    @status.exitstatus
+  end
+
+  def ok?
+    exitstatus == 0
+  end
+
+end
+
+class TestbeatShellStub
+
+  def initialize()
+    @hasrun = Array.new
+  end
+
+  def hasrun
+    @hasrun
+  end
+
+  def exec(cmd)
+    @hasrun.push(cmd)
+    $logger.warn "No guest shell available to exec: '#{cmd}'"
+  end
+
+  def out
+    "(No guest shell for current testbeat context)"
+  end
+
+  def exitstatus
+    @hasrun.length
+  end
+
+  def ok?
+    false
+  end
+end
+
+# Context has getters for test case parameters that can be digged out from Rspec examples,
+# initialized for each "it"
+class TestbeatContext
+
+  # reads context from RSpec example metadata
+  def initialize(example)
+    # enables de-duplication of requests within describe, using tostring to compare becase == wouldn't work
+    @context_block_id = "#{example.metadata[:example_group][:block]}"
+
+    # defaults
+    @user = { :username => 'testuser', :password => 'testpassword' }
+    @unencrypted = false
+    @unauthenticated = false
+    @rest = false
+    @reprovision = false
+
+    # actual context
+    parse_example_group(example.metadata[:example_group], 0)
+
+    @context_block_id_short = /([^\/]+)>$/.match(@context_block_id)[1]
+    logger.info{ "#{example.metadata[:example_group][:location]}: #{@rest ? @method : ''} #{@resource} #{@unencrypted ? '[unencrypted] ' : ' '}#{@unauthenticated ? '[unauthenticated] ' : ' '}" }
+  end
+
+  def logger
+    $logger
+  end
+
+  def context_block_id
+    @context_block_id
+  end
+
+  # Returns true if the current context has a REST request specified
+  def rest?
+    @rest
+  end
+
+  def nop?
+    !rest?
+  end
+
+  def user
+    @user
+  end
+
+  # Returns the REST resource if specified in context
+  def resource
+    if not rest?
+      return nil
+    end
+    @resource
+  end
+
+  def method
+    if not rest?
+      return nil
+    end
+    @method
+  end
+
+  def headers
+    @rest_headers
+  end
+
+  def headers?
+    !!headers
+  end
+
+  def body
+    @rest_body
+  end
+
+  def body?
+    !!body
+  end
+
+  def form
+    @rest_form
+  end
+
+  def form?
+    !!form
+  end
+
+  # Returns true if requests will be made without authentication even if the node expects authentication
+  def unauthenticated?
+    unencrypted? || @unauthenticated
+  end
+
+  def unencrypted?
+    @unencrypted
+  end
+
+  def reprovision?
+    @reprovision
+  end
+
+  def to_s
+    s = "Testbeat context"
+    if rest?
+      s += " #{method} #{resource}"
+    else
+      s += " non-REST"
+    end
+    if @unencrypted
+      s += " unencrypted"
+    elsif @unauthenticated
+      s += " unauthenticated"
+    end
+    s
+  end
+
+  private
+
+  def parse_example_group(example_group, uplevel)
+    if example_group[:parent_example_group]
+      parse_example_group(example_group[:parent_example_group], uplevel + 1)
+    end
+    logger.debug{ "Parsing context #{uplevel > 0 ? '-' : ' '}#{uplevel}: #{example_group[:description]}" }
+    parse_description_args(example_group[:description_args])
+    if rest?
+      if example_group[:body]
+        @rest_body = example_group[:body]
+      end
+      if example_group[:form]
+        @rest_form = example_group[:form]
+      end
+      if example_group[:headers]
+        @rest_headers = example_group[:headers]
+      end
+    end
+
+  end
+
+  def parse_description_args(example_group_description_args)
+    a = example_group_description_args[0]
+    /unencrypted/i.match(a) {
+      @unencrypted = true
+    }
+
+    /unauthenticated/i.match(a) {
+      @unauthenticated = true
+    }
+    # We could iterate methods in Net::HTTP and support all
+    # Change method to rest_method for consistency
+    /(GET|HEAD|POST)\s+(\S*)(.*)/.match(a) { |rest|
+      @rest = true
+      @method = rest[1]
+      @resource = rest[2]
+    }
+    /reprovision/i.match(a) {
+      @reprovision = true
+    }
+    # idea: nodes that should not be modified (production etc), particularily not through shell
+    #/untouchable/
+  end
+
+end
+
+$_testbeat_rest_reuse = Hash.new
+
+class TestbeatRestRequest
+
+  def initialize(node, testbeat)
+    #@headers = {}
+    @timeout = 10
+    @node = node
+    @testbeat = testbeat
+  end
+
+  # Initiate the request and return Net::HTTPResponse object,
+  # supporting response [:responseHeaderName], .body (string), .code (int), .msg (string)
+  def run
+    reuse_id = @testbeat.context_block_id
+    previous = $_testbeat_rest_reuse[reuse_id]
+    if previous
+      @response = previous
+      @testbeat.logger.info{ "Request reused within #{reuse_id} responded #{@response.code} #{@response.message}" }
+      return @response
+    end
+    # If there's no built in auth support in Net::HTTP we can check for 401 here and re-run the request with auth header
+    Net::HTTP.start(@node.host,
+      :use_ssl => !@testbeat.unencrypted?,
+      :verify_mode => OpenSSL::SSL::VERIFY_NONE,  # Ideally verify should be enabled for non-labs hosts (anything with a FQDN including dots)
+      :open_timeout => @timeout,
+      :read_timeout => @timeout
+      ) do |http|
+
+      req = Net::HTTP::Get.new(@testbeat.resource)
+      if @testbeat.method == 'POST'
+        req = Net::HTTP::Post.new(@testbeat.resource)
+        if @testbeat.form?
+          req.set_form_data(@testbeat.form)
+        end
+        if @testbeat.body?
+          req.body = @testbeat.body
+        end
+      end
+      if @testbeat.headers?
+        @testbeat.headers.each {|name, value| req[name] = value }
+      end
+
+      @response = http.request(req) # Net::HTTPResponse object
+
+      if @response.code == "401" and @testbeat.user and not @testbeat.unauthenticated?
+        u = @testbeat.user
+        @testbeat.logger.info{ "Authenticating to #{@testbeat.resource} with #{u[:username]}:#{u[:password]}" }
+        req.basic_auth u[:username], u[:password]
+        @response = http.request(req)
+      end
+
+      @testbeat.logger.info{ "Request #{@testbeat.resource} responded #{@response.code} #{@response.message}" }
+      $_testbeat_rest_reuse[reuse_id] = @response
+      return @response
+    end
+  end
+
+end
+
+RSpec.configure do |config|
+
+  activenodes = {}
+
+  # We can't use before(:suite) because it does not support instance variables
+  config.before(:context) do |context|
+
+    nodearg = ENV['NODE']
+    next if nodearg.nil?
+
+    if not activenodes.has_key?(nodearg)
+      activenodes[nodearg] = TestbeatNode.new(nodearg)
+    end
+    @node = activenodes[nodearg]
+
+  end
+
+  # https://www.relishapp.com/rspec/rspec-core/docs/hooks/before-and-after-hooks
+  config.before(:example) do |example|
+    #puts "------------- before"
+    #ap example.metadata
+    #ap example.metadata[:description_args]
+    #ap example[:description_args]
+    #ap example.full_description
+
+    # Testbeat can do nothing without a node, so the example will continue as a regular Rspec test
+    next if not @node
+
+    @testbeat = TestbeatContext.new(example)
+
+    # If there's no REST call in the example we're happy just to define @testbeat with access to command line etc
+    next if @testbeat.nop?
+
+    if @testbeat.unencrypted? and @testbeat.unauthenticated?
+      # Nodes that require non-test authentication are currently out of scope for the test framework
+      # This means we must skip specs in an "unauthenticated" context, or let them fail, because we won't get the 401 responses we'd expect
+      #p "--- Should be skipped; nodes that require authentication are currently unsupported"
+    elsif @testbeat.unencrypted?
+      # When we do add support for authentication to nodes, there should be no authentication on insecure channel
+    elsif @testbeat.reprovision?
+      # We have to run a new provisioning. For repos-backup amongst others.
+      @testbeat.logger{ "Reprovision triggered" }
+      @node.provision
+    else
+      # Authenticated is default, meaning that specs should be written with the assumption that all services are accessible
+    end
+
+    if @testbeat.rest?
+      @testbeat.logger{ "Request triggered" }
+      req = TestbeatRestRequest.new(@node, @testbeat)
+      begin
+        @response = req.run
+      rescue OpenSSL::SSL::SSLError => e
+        @response = { :error => e }
+      end
+    end
+
+    #p "Got reponse code #{@response.code}"
+    #ap @response.header.to_hash
+  end
+
+  config.after(:example) do
+    #p "------------- after"
+  end
+end

data/lib/testbeat.rb

@@ -0,0 +1,14 @@
+
+#require 'testbeat/rspec'
+#require 'testbeat/vagrant'
+require_relative './spec_helper.rb'
+
+#module testbeat
+#
+#  autoload :RSpec, './spec_helper.rb'
+#
+#  def configure
+#    yield configuration
+#  end
+#
+#end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: testbeat
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Staffan Olsson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rspec spec_helper and Vagrant integration for HTTP level testing, on
+  a box from the outside
+email: solsson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/testbeat.rb
+- lib/spec_helper.rb
+homepage: https://github.com/Reposoft/testbeat
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ~>
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: REST acceptance testing framework
+test_files: []