r-train 0.9.1

data/lib/train/version.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+#
+# Author:: Dominik Richter (<dominik.richter@gmail.com>)
+
+module Train
+  VERSION = '0.9.1'
+end

data/test/integration/.kitchen.yml

@@ -0,0 +1,43 @@
+---
+driver:
+  name: vagrant
+
+provisioner:
+  name: chef_solo
+  data_path: ../../.
+
+platforms:
+  - name: centos-7.1
+  - name: centos-6.7
+  - name: centos-6.7-i386
+  - name: centos-5.11
+  - name: centos-5.11-i386
+  - name: debian-6.0.10
+  - name: debian-6.0.10-i386
+  - name: debian-7.8
+  - name: debian-7.8-i386
+  - name: debian-8.1
+  - name: debian-8.1-i386
+  - name: fedora-21
+  - name: fedora-21-i386
+  - name: fedora-22
+  - name: freebsd-9.3
+  - name: freebsd-10.2
+  - name: opensuse-13.2-x86_64
+  - name: opensuse-13.2-i386
+  - name: ubuntu-14.04
+  - name: ubuntu-14.04-i386
+  - name: ubuntu-12.04
+  - name: ubuntu-12.04-i386
+  - name: ubuntu-10.04
+  - name: ubuntu-10.04-i386
+
+suites:
+  - name: default
+    run_list:
+      - recipe[sudo]
+      - recipe[test]
+    attributes:
+      authorization:
+        sudo:
+          include_sudoers_d: true

data/test/integration/Berksfile

@@ -0,0 +1,3 @@
+source 'https://supermarket.chef.io'
+cookbook 'sudo', '~> 2.7.2'
+cookbook 'test', path: 'cookbooks/test'

data/test/integration/bootstrap.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+test ! -e /tmp/folder && \
+  mkdir /tmp/folder
+chmod 0567 /tmp/folder
+
+echo -n 'hello world' > /tmp/file
+test ! -e /tmp/symlink && \
+  ln -s /tmp/file /tmp/symlink
+chmod 0777 /tmp/symlink
+chmod 0765 /tmp/file
+
+test ! -e /tmp/pipe && \
+  mkfifo /tmp/pipe
+
+test ! -e /tmp/block_device && \
+  mknod /tmp/block_device b 7 7
+chmod 0666 /tmp/block_device

data/test/integration/chefignore

@@ -0,0 +1 @@
+.kitchen

data/test/integration/cookbooks/test/metadata.rb

@@ -0,0 +1 @@
+name 'test'

data/test/integration/cookbooks/test/recipes/default.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+# author: Dominik Richter
+#
+# Helper recipe to create create a few files in the operating
+# systems, which the runner will test against.
+# It also initializes the runner inside the machines
+# and makes sure all dependencies are ready to go.
+#
+# Finally (for now), it actually executes the all tests with
+# the local execution backend
+
+gid = 'root'
+gid = 'wheel' if node['platform_family'] == 'freebsd'
+
+file '/tmp/file' do
+  mode '0765'
+  owner 'root'
+  group gid
+  content 'hello world'
+end
+
+directory '/tmp/folder' do
+  mode '0567'
+  owner 'root'
+  group gid
+end
+
+link '/tmp/symlink'do
+  to '/tmp/file'
+  owner 'root'
+  group gid
+  mode '0777'
+end
+
+execute 'create pipe/fifo' do
+  command 'mkfifo /tmp/pipe'
+  not_if 'test -e /tmp/pipe'
+end
+
+execute 'create block_device' do
+  command "mknod /tmp/block_device b 7 7 && chmod 0666 /tmp/block_device && chown root:#{gid} /tmp/block_device"
+  not_if 'test -e /tmp/block_device'
+end
+
+# prepare ssh for backend
+execute 'create ssh key' do
+  command 'ssh-keygen -t rsa -b 2048 -f /root/.ssh/id_rsa -N ""'
+  not_if 'test -e /root/.ssh/id_rsa'
+end
+
+execute 'add ssh key to vagrant user' do
+  command 'cat /root/.ssh/id_rsa.pub >> /home/vagrant/.ssh/authorized_keys'
+end
+
+execute 'test ssh connection' do
+  command 'ssh -o StrictHostKeyChecking=no -i /root/.ssh/id_rsa vagrant@localhost "echo 1"'
+end
+
+# prepare a few users
+%w{ nopasswd passwd nosudo }.each do |name|
+  user name do
+    password '$1$7MCNTXPI$r./jqCEoVlLlByYKSL3sZ.'
+    manage_home true
+  end
+end
+
+%w{nopasswd vagrant}.each do |name|
+  sudo name do
+    user '%'+name
+    nopasswd true
+  end
+end
+
+sudo 'passwd' do
+  user 'passwd'
+  nopasswd false
+end
+
+# execute tests
+execute 'bundle install' do
+  command '/opt/chef/embedded/bin/bundle install'
+  cwd '/tmp/kitchen/data'
+end
+
+execute 'run local tests' do
+  command '/opt/chef/embedded/bin/ruby -I lib test/integration/test_local.rb test/integration/tests/*_test.rb'
+  cwd '/tmp/kitchen/data'
+end
+
+execute 'run ssh tests' do
+  command '/opt/chef/embedded/bin/ruby -I lib test/integration/test_ssh.rb test/integration/tests/*_test.rb'
+  cwd '/tmp/kitchen/data'
+end
+
+%w{passwd nopasswd}.each do |name|
+  execute "run local sudo tests as #{name}" do
+    command "/opt/chef/embedded/bin/ruby -I lib test/integration/sudo/#{name}.rb"
+    cwd '/tmp/kitchen/data'
+    user name
+  end
+end

data/test/integration/docker_run.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+# author: Dominik Richter
+
+require 'docker'
+require 'yaml'
+require 'concurrent'
+
+class DockerRunner
+  def initialize(conf_path = nil)
+    @conf_path = conf_path || ENV['config']
+    unless File.file?(@conf_path)
+      fail "Can't find configuration in #{@conf_path}"
+    end
+
+    @conf = YAML.load_file(@conf_path)
+    if @conf.nil? or @conf.empty?
+      fail "Can't read coniguration in #{@conf_path}"
+    end
+    if @conf['images'].nil?
+      fail "You must configure test images in your #{@conf_path}"
+    end
+
+    @images = docker_images_by_tag
+    @image_pull_tickets = Concurrent::Semaphore.new(2)
+    @docker_run_tickets = Concurrent::Semaphore.new(5)
+  end
+
+  def run_all(&block)
+    fail 'You must provide a block for run_all' unless block_given?
+
+    promises = @conf['images'].map do |id|
+      run_on_target(id, &block)
+    end
+
+    # wait for all tests to be finished
+    sleep(0.1) until promises.all?(&:fulfilled?)
+
+    # return resulting values
+    promises.map(&:value)
+  end
+
+  def run_on_target(name, &block)
+    pr = Concurrent::Promise.new {
+      begin
+        container = start_container(name)
+        res = block.call(name, container)
+      # special rescue block to handle not implemented error
+      rescue NotImplementedError => err
+        raise err.message
+      end
+      # always stop the container
+      stop_container(container)
+      res
+    }.execute
+
+    # failure handling
+    pr.rescue do |err|
+      msg = "\033[31;1m#{err.message}\033[0m"
+      puts msg
+      msg + "\n" + err.backtrace.join("\n")
+    end
+  end
+
+  def provision_image(image, prov, files)
+    tries ||= 3
+    return image if prov['script'].nil?
+    path = File.join(File.dirname(@conf_path), prov['script'])
+    unless File.file?(path)
+      puts "Can't find script file #{path}"
+      return image
+    end
+    puts "    script #{path}"
+    dst = "/bootstrap#{files.length}.sh"
+    files.push(dst)
+    image.insert_local('localPath' => path, 'outputPath' => dst)
+  rescue StandardError => _
+    retry unless (tries -= 1).zero?
+  end
+
+  def bootstrap_image(name, image)
+    files = []
+    provisions = Array(@conf['provision'])
+    puts "--> provision docker #{name}" unless provisions.empty?
+    provisions.each do |prov|
+      image = provision_image(image, prov, files)
+    end
+    [image, files]
+  end
+
+  def start_container(name, version = nil)
+    unless name.include?(':')
+      version ||= 'latest'
+      name = "#{name}:#{version}"
+    end
+    puts "--> schedule docker #{name}"
+
+    image = @images[name]
+    if image.nil?
+      puts "\033[35;1m--> pull docker images #{name} "\
+           "(this may take a while)\033[0m"
+
+      @image_pull_tickets.acquire(1)
+      puts "... start pull image #{name}"
+      image = Docker::Image.create('fromImage' => name)
+      @image_pull_tickets.release(1)
+
+      unless image.nil?
+        puts "\033[35;1m--> pull docker images finished for #{name}\033[0m"
+      end
+    end
+
+    fail "Can't find nor pull docker image #{name}" if image.nil?
+
+    @docker_run_tickets.acquire(1)
+
+    image, scripts = bootstrap_image(name, image)
+
+    puts "--> start docker #{name}"
+    container = Docker::Container.create(
+      'Cmd' => %w{sleep 3600},
+      'Image' => image.id,
+      'OpenStdin' => true,
+    )
+    container.start
+
+    scripts.each do |script|
+      container.exec(%w{chmod +x}.push(script))
+      container.exec(%w{sh -c}.push(script))
+    end
+
+    container
+  end
+
+  def stop_container(container)
+    @docker_run_tickets.release(1)
+    puts "--> killrm docker #{container.id}"
+    container.kill
+    container.delete(force: true)
+  end
+
+  private
+
+  # get all docker image tags
+  def docker_images_by_tag
+    images = {}
+    Docker::Image.all.map do |img|
+      Array(img.info['RepoTags']).each do |tag|
+        images[tag] = img
+      end
+    end
+    images
+  end
+end

data/test/integration/docker_test.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require_relative 'docker_run'
+tests = ARGV
+
+def test_container(container, tests)
+  puts "--> run test on docker #{container.id}"
+  pid = Process.fork do
+    ENV['CONTAINER'] = container.id
+    require_relative 'docker_test_container.rb'
+    Process.exit
+  end
+
+  _, status = Process.waitpid2(pid)
+  status.exitstatus == 0
+end
+
+results = DockerRunner.new.run_all do |name, container|
+  status = test_container(container, tests)
+  status ? nil : "Failed to run tests on #{name}"
+end
+
+failures = results.compact
+failures.each { |f| puts "\033[31;1m#{f}\033[0m\n\n" }
+failures.empty? or fail 'Test failures'

data/test/integration/docker_test_container.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+# author: Dominik Richter
+
+require 'train'
+require_relative 'helper'
+
+container_id = ENV['CONTAINER'] or
+  fail 'You must provide a container ID via CONTAINER env'
+
+tests = ARGV
+puts ['Running tests:', tests].flatten.join("\n- ")
+puts ''
+
+backends = {}
+backends[:docker] = proc { |*args|
+  opt = Train.target_config({ host: container_id })
+  Train.create('docker', opt).connection(args[0])
+}
+
+backends.each do |type, get_backend|
+  tests.each do |test|
+    instance_eval(File.read(test), test, 1)
+  end
+end

data/test/integration/helper.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+# author: Dominik Richter
+
+require 'minitest/autorun'
+require 'minitest/spec'
+
+# Tests configuration:
+module Test
+  class << self
+    # MTime tracks the maximum range of modification time in seconds.
+    # i.e. MTime == 60*60*1 is 1 hour of modification time range,
+    # which translates to a modification time range of:
+    #   [ now-1hour, now ]
+    def mtime
+      60 * 60 * 24 * 1
+    end
+
+    def dup(o)
+      Marshal.load(Marshal.dump(o))
+    end
+
+    def root_group(os)
+      if os[:family] == 'freebsd'
+        'wheel'
+      else
+        'root'
+      end
+    end
+
+    def selinux_label(backend, path = nil)
+      return nil if backend.class.to_s =~ /docker/i
+
+      os = backend.os
+      labels = {}
+
+      h = {}
+      h.default = Hash.new(nil)
+      h['redhat'] = {}
+      h['redhat'].default = 'unconfined_u:object_r:user_tmp_t:s0'
+      h['redhat']['5.11'] = 'user_u:object_r:tmp_t'
+      h['centos'] = h['fedora'] = h['redhat']
+      labels.default = dup(h)
+
+      h['redhat'].default = 'unconfined_u:object_r:tmp_t:s0'
+      labels['/tmp/block_device'] = dup(h)
+
+      h = {}
+      h.default = Hash.new(nil)
+      h['redhat'] = {}
+      h['redhat'].default = 'system_u:object_r:null_device_t:s0'
+      h['redhat']['5.11'] = 'system_u:object_r:null_device_t'
+      h['centos'] = h['fedora'] = h['redhat']
+      labels['/dev/null'] = dup(h)
+
+      labels[path][os[:family]][os[:release]]
+    end
+  end
+end