puppet-ci-testing 0.11.0

data/lib/simple_junit.rb

@@ -0,0 +1,165 @@
+require 'singleton'
+require 'time'
+
+module SimpleJUnit
+
+  class TestSuiteCollection
+
+    include Singleton
+
+    attr :testsuites
+
+    def initialize
+      # initialization code needs to be put in reset method for testing
+      self.reset
+    end
+
+    def create_testsuite(name)
+      @testsuites << SimpleJUnit::TestSuite.new(name)
+      @testsuites.last
+    end
+
+    def to_s
+      return <<-EOTC
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+#{(@testsuites.each {|ts| ts.to_s}).join}
+</testsuites>
+EOTC
+    end
+
+    # This is really the initialize method, but for testing we want to be
+    # able to reset the singleton to an initialized state
+    def reset
+      @testsuites = []
+    end
+  end
+
+
+  class TestSuite
+
+    attr :name
+    attr_accessor :testcases
+
+    def initialize(name)
+      @name = name
+      @timestamp = Time.now()
+      @testcases = []
+    end
+
+    def add_testcase(testcase)
+      unless @testcases.include? testcase
+        @testcases << testcase
+      end
+    end
+
+    def create_testcase(name, desc=nil)
+      @testcases << TestCase.new(name, desc)
+      @testcases.last
+    end
+
+    def to_s
+      num_testcase = @testcases.count
+      num_failures = (@testcases.select {|tc| tc.failed?}).count
+
+      return <<-EOTS
+  <testsuite name="#{@name}" errors="0" tests="#{num_testcase}" failures="#{num_failures}" time="0" timestamp="#{@timestamp.iso8601}">
+    <properties/>
+#{(@testcases.collect {|tc| tc.to_s}).join}
+  </testsuite>
+EOTS
+    end
+  end
+
+
+  class TestCase
+
+    attr :classname
+    attr :description
+    attr :duration
+    attr :status
+    attr :errors
+    attr :output
+
+    def initialize(name, desc=nil, duration=nil)
+      @classname = name
+      @description = desc
+      @duration = duration
+      @status = :pending
+      @errors = nil
+      @output = nil
+    end
+
+    def passed(output:nil, error:nil)
+      @status = :passed
+      unless output.nil?
+        @output = output
+      end
+      unless error.nil?
+        @errors = error
+      end
+    end
+
+    def passed?
+      @status == :passed
+    end
+
+    def failed(type:nil, output:nil, error:nil)
+      @status = :failed
+      @error_type = type || 'unspecified'
+      unless output.nil?
+        @output = output
+      end
+      unless error.nil?
+        @errors = error
+      end
+    end
+
+    def failed?
+      @status == :failed
+    end
+
+    def pending?
+      @status == :pending
+    end
+
+    def skip
+      @status = :skipped
+    end
+
+    def skipped?
+      @status == :skipped
+    end
+
+    def start
+      @started = Time.now
+    end
+
+    def finish
+      @duration = Time.now - @started
+    end
+
+
+    def to_s
+      xml = "    <testcase classname=\"#{@classname}\" "
+      unless @description.nil?
+        xml += "name=\"#{@description}\" "
+      end
+      xml += "time=\"#{@duration}\">\n"
+
+      case @status
+      when :skipped
+        xml += "      <skipped/>\n"
+      when :failed
+        xml += "      <failure message=\"#{@error_type}\">#{@errors}</failure>\n"
+      end
+
+      xml += "      <system-out>#{@output}</system-out>\n" if @output
+      xml += "      <system-err>#{@errors}</system-err>\n" if @errors
+
+      xml += "    </testcase>\n"
+      return xml
+    end
+
+  end
+end

data/spec/check_file_syntax_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'check_file_syntax'
+
+describe 'CheckFileSyntax' do
+  
+  { :json   =>  '.json', 
+    :yaml   =>  ['.yaml','.yml'],
+    :perl   =>  ['.pl','.pm'],
+    :bash   =>  ['.sh','.bash','.zsh','.ksh'],
+    :ruby   =>  '.rb', 
+    :python =>  '.py', 
+    :erb    =>  '.erb',
+    :puppet =>  '.pp' }.each_pair do |type, exts|
+      [exts].flatten.each do |ext|
+        it "identifies #{type} with #{ext} extension" do
+          expect(CheckFileSyntax::type_of_file("foo#{ext}", type, exts)).to eq true
+        end
+      end
+    end
+  
+  { :json   =>  '.json', 
+    :yaml   =>  ['.yaml','.yml'],
+    :perl   =>  ['.pl','.pm'],
+    :bash   =>  ['.sh','.bash','.zsh','.ksh'],
+    :ruby   =>  '.rb', 
+    :python =>  '.py', 
+    :erb    =>  '.erb',
+    :puppet =>  '.pp' }.each_pair do |type, exts|
+      bad_ext = random_string(8)
+      [exts].flatten.each do |ext|
+        it "fails identifying #{type} without #{ext} extension" do
+          expect(CheckFileSyntax::type_of_file("foo.#{bad_ext}", type, exts)).to eq false
+        end
+      end
+    end
+    
+  CheckFileSyntax::ALL_CHECKS.each do |type|
+    bad_ext ||= random_string(8)
+    # Puppet, ERB, JSON and YAML files don't have shebang lines
+    unless [:puppet, :erb, :json, :yaml].include? type
+      it "identifies content as #{type}" do
+        filename = eval "generate_#{type.to_s}(:valid, extension:'.#{bad_ext}')"
+        expect(CheckFileSyntax::type_of_file(filename, type, '.foo')).to eq true
+        File.unlink filename
+      end
+    end
+  end
+  
+  CheckFileSyntax::ALL_CHECKS.each do |type|
+    it "identifies valid syntax of #{type}" do
+      filename = eval "generate_#{type.to_s}(:valid)"
+      CheckFileSyntax::check_file_syntax(filename) { |path, status, errors|
+        expect(status).to eq :passed
+      }
+      File.unlink filename
+      File.unlink "#{filename}c" if type == :python
+    end
+  end
+
+  CheckFileSyntax::ALL_CHECKS.each do |type|
+    it "identifies invalid syntax of #{type}" do
+      filename = eval "generate_#{type.to_s}(:invalid)"
+      CheckFileSyntax::check_file_syntax(filename) { |path, status, errors|
+        expect(status).to eq :failed
+      }
+      File.unlink filename
+    end
+  end
+  
+  
+end

data/spec/simple_junit_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+require 'simple_junit'
+
+describe 'SimpleJUnit' do
+  describe 'TestSuiteCollection' do 
+    it 'creates an empty test suite collection' do
+      tc = SimpleJUnit::TestSuiteCollection.instance
+      expect(tc.testsuites).to eq []
+      tc.reset
+    end
+    
+    it 'creates two test suite collections' do
+      tc = SimpleJUnit::TestSuiteCollection.instance
+      tc.create_testsuite('foo')
+      tc.create_testsuite('bar')
+      expect(tc.testsuites.count).to eq 2
+      tc.reset
+    end
+    
+    it 'generates valid JUnit XML output' do
+      tc = SimpleJUnit::TestSuiteCollection.instance
+      xml = tc.to_s.gsub(/\n\s*/, "")
+      expect(xml).to match /<\?xml version="1.0" encoding="UTF-8"\?><testsuites><\/testsuites>/
+      tc.reset
+    end
+    
+    it 'generates valid JUnit XML output with test suites' do
+      tc = SimpleJUnit::TestSuiteCollection.instance
+      tc.create_testsuite('foo')
+      tc.create_testsuite('bar')
+      xml = tc.to_s.gsub(/\n\s*/, "")
+      expect(xml).to match /<\?xml version="1.0" encoding="UTF-8"\?>/
+      expect(xml).to match /\s*<testsuite name="foo" errors="0" tests="0" failures="0" time="0" timestamp="[^\"]+">/
+      expect(xml).to match /\s*<testsuite name="bar" errors="0" tests="0" failures="0" time="0" timestamp="[^\"]+">/
+      tc.reset
+    end
+  end
+  
+  
+  describe 'TestSuite' do
+    it 'generates valid XML' do
+      name = random_string(5)
+      ts = SimpleJUnit::TestSuite.new(name)
+      t1 = random_string(3)
+      ts.create_testcase(t1).passed
+      t2 = random_string(3)
+      ts.create_testcase(t2).failed
+      t3 = random_string(3)
+      ts.create_testcase(t3).failed
+      t4 = random_string(3)
+      ts.create_testcase(t4).passed
+      t5 = random_string(3)
+      ts.create_testcase(t5).skip
+      xml = ts.to_s.gsub(/\n\s*/, "")
+      expect(xml).to match /<testsuite name="#{name}" errors="0" tests="5" failures="2" time="0" timestamp="[^"]+"><properties\/><testcase classname="#{t1}" time=""><\/testcase><testcase classname="#{t2}" time=""><failure message="unspecified"><\/failure><\/testcase><testcase classname="#{t3}" time=""><failure message="unspecified"><\/failure><\/testcase><testcase classname="#{t4}" time=""><\/testcase><testcase classname="#{t5}" time=""><skipped\/><\/testcase><\/testsuite>/
+    end
+    
+  end
+  
+  
+  describe 'TestCase' do
+    it 'passed() sets internal state correctly' do
+      t = SimpleJUnit::TestCase.new('foo')
+      output = random_string(30)
+      error = random_string(20)
+      t.passed(output: output, error: error)
+      expect(t.status).to eq :passed
+      expect(t.output).to eq output
+      expect(t.errors).to eq error
+    end
+    
+    it 'passed? test correct' do
+      t = SimpleJUnit::TestCase.new('foo')
+      expect(t.passed?).to eq false
+      t.passed
+      expect(t.passed?).to eq true
+      t.failed
+      expect(t.passed?).to eq false
+      t.skip
+      expect(t.passed?).to eq false
+    end
+    
+    it 'failed() sets internal state correctly with error type' do
+      t = SimpleJUnit::TestCase.new('foo')
+      output = random_string(30)
+      error = random_string(20)
+      t.failed(type:'bar', output:output, error:error)
+      expect(t.status).to eq :failed
+      expect(t.output).to eq output
+      expect(t.errors).to eq error
+    end
+    
+    it 'failed() sets internal state correctly without error type' do
+      t = SimpleJUnit::TestCase.new('foo')
+      output = random_string(30)
+      error = random_string(20)
+      t.failed(:output => output, :error => error)
+      expect(t.status).to eq :failed
+      expect(t.output).to eq output
+      expect(t.errors).to eq error
+    end
+    
+    it 'failed? test correct' do
+      t = SimpleJUnit::TestCase.new('foo')
+      expect(t.failed?).to eq false
+      t.failed
+      expect(t.failed?).to eq true
+      t.passed
+      expect(t.failed?).to eq false
+      t.skip
+      expect(t.passed?).to eq false
+    end
+    
+    it 'pending? test correct' do
+      t = SimpleJUnit::TestCase.new('foo')
+      expect(t.pending?).to eq true
+      t.failed
+      expect(t.pending?).to eq false
+      t.passed
+      expect(t.pending?).to eq false
+      t.skip
+      expect(t.pending?).to eq false
+    end
+    
+    it 'skipped? test correct' do
+      t = SimpleJUnit::TestCase.new('foo')
+      expect(t.skipped?).to eq false
+      t.failed
+      expect(t.skipped?).to eq false
+      t.passed
+      expect(t.skipped?).to eq false
+      t.skip
+      expect(t.skipped?).to eq true
+    end
+    
+    it 'duration is calculated correctly' do
+      t = SimpleJUnit::TestCase.new('foo')
+      t.start
+      sleep(2)
+      t.finish
+      expect(t.duration.to_i).to eq 2
+    end
+    
+    it 'generates correct XML' do
+      name = random_string(5)
+      type = random_string(7)
+      output = random_string(13)
+      error = random_string(11)
+      t = SimpleJUnit::TestCase.new(name)
+      t.passed(output: output, error: error)
+      xml = t.to_s.gsub(/\n\s*/, '')
+      expect(xml).to match /<testcase classname="#{name}" time=""><system-out>#{output}<\/system-out><system-err>#{error}<\/system-err><\/testcase>/
+    end
+  end
+end
+
+    

data/spec/spec_helper.rb

@@ -0,0 +1,288 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end
+
+def random_string(size=10)
+  (0..size).map { ('a'..'z').to_a[rand(26)] }.join
+end
+
+
+def generate_json(validity, extension: '.json')
+  filebase = random_string(16)
+  if validity == :valid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+{
+  "test": "good JSON",
+  "foo": "bar"
+}
+EOF
+    end
+  elsif validity == :invalid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+{
+  "test": "bad JSON"
+  "foo": "bar"
+}
+EOF
+    end
+  end
+  
+  return filebase + extension
+end
+
+
+def generate_yaml(validity, extension: '.yaml')
+  filebase = random_string(16)
+  if validity == :valid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+---
+  test: "good YAML"
+  foo: "bar"
+EOF
+    end
+  elsif validity == :invalid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+===
+  test: "bad YAML",
+  foo: "bar"
+EOF
+    end
+  end
+  
+  return filebase + extension
+end
+
+
+def generate_ruby(validity, extension: '.rb')
+  filebase = random_string(16)
+  if validity == :valid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+#!/usr/bin/env ruby
+puts "valid ruby!"
+EOF
+    end
+  elsif validity == :invalid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+#!/usr/bin/env ruby
+put "invalid ruby!'
+EOF
+    end
+  end
+  
+  return filebase + extension
+end
+
+
+def generate_python(validity, extension: '.py')
+  filebase = random_string(16)
+  if validity == :valid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+#!/usr/bin/env python
+print("valid python!")
+EOF
+    end
+  elsif validity == :invalid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+#!/usr/bin/env python
+print("invalid python!')
+EOF
+    end
+  end
+  
+  return filebase + extension
+end
+
+
+def generate_perl(validity, extension: '.pl')
+  filebase = random_string(16)
+  if validity == :valid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+#!/usr/bin/env perl
+print "valid ";
+print "perl!"
+EOF
+    end
+  elsif validity == :invalid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+#!/usr/bin/env perl
+print "invalid "
+print "perl!"
+EOF
+    end
+  end
+  
+  return filebase + extension
+end
+
+
+def generate_bash(validity, extension: '.sh')
+  filebase = random_string(16)
+  if validity == :valid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+#!/bin/bash
+echo "valid shell!"
+EOF
+    end
+  elsif validity == :invalid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+#!/bin/bash
+echo "invalid shell!'
+EOF
+    end
+  end
+  
+  return filebase + extension
+end
+
+
+def generate_erb(validity, extension: '.erb')
+  filebase = random_string(16)
+  if validity == :valid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+<% puts "valid erb!" %>
+EOF
+    end
+  elsif validity == :invalid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+<% puts "invalid "  <%= erb!" %>
+EOF
+    end
+  end
+  
+  return filebase + extension
+end
+
+
+def generate_puppet(validity, extension: '.pp')
+  filebase = random_string(16)
+  if validity == :valid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+puppet { 'good': }
+EOF
+    end
+  elsif validity == :invalid
+    open(filebase + extension, 'w') do |fh|
+      fh.puts <<EOF
+puppet { "bad" }
+EOF
+    end
+  end
+  
+  return filebase + extension
+end
+