tests

Author: andykent

Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rake'
+gem 'mocha', :require => false

Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    hull (0.1.0)
+      colored
+      net-ssh
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    colored (1.2)
+    metaclass (0.0.1)
+    mocha (0.13.1)
+      metaclass (~> 0.0.1)
+    net-ssh (2.6.7)
+    rake (10.0.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  hull!
+  mocha
+  rake

Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/**/*_test.rb'
+end
+
+task :default => :test

bin/hull

@@ -12,7 +12,9 @@ require Dir.pwd + '/config/hull'
 
 
 if arg_command == 'apply'
-  apply(arg_node, arg_package, :install)
+  execute(arg_node, arg_package, :apply)
+elsif arg_command == 'remove'
+  execute(arg_node, arg_package, :remove)
 else
-  demonstrate(arg_node, arg_package, :install)
+  demonstrate(arg_node, arg_package, :apply)
 end

lib/hull.rb

@@ -6,4 +6,6 @@ module Hull; end
 require_relative "./hull/package_index"
 require_relative "./hull/node"
 require_relative "./hull/runner"
+require_relative "./hull/resolver"
+require_relative "./hull/execution_context"
 require_relative "./hull/dsl"

lib/hull/dsl.rb

@@ -7,10 +7,10 @@ def package(name, &definition)
       Hull::PackageIndex.default.add(pkg)
     end
 
-    def apply(node_name, pkg_name, command)
+    def execute(node_name, pkg_name, command)
       node = Hull::Node.find(node_name)
       pkg = Hull::PackageIndex.default.get(pkg_name)
-      Hull::Runner.new(node, pkg).apply(command)
+      Hull::Runner.new(node, pkg).execute(command)
     end
 
     def demonstrate(node_name, pkg_name, command)

lib/hull/execution_context.rb

@@ -0,0 +1,31 @@
+class Hull::ExecutionContext
+  def initialize(node)
+    @node = node
+  end
+
+  def apply(blk)
+    instance_eval(&blk)
+  end
+
+  def run(cmd)
+    @node.execute(cmd)
+  end
+
+  def trigger(action_ref, *args)
+    pkg_name, action_name = *action_ref.split(':', 2)
+    pkg = Hull::PackageIndex.default.get(pkg_name)
+    action = pkg.actions[action_name]
+    raise "Action #{action_ref} could not be found." unless action
+    instance_exec(*args, &action)
+  end
+
+  def binary_exists?(binary)
+    run("which #{binary}") =~ /\/#{binary}/
+  end
+end
+
+class Hull::MockExecutionContext < Hull::ExecutionContext
+  def run(cmd)
+    @node.log 'mock-execute', cmd
+  end
+end

lib/hull/node.rb

@@ -1,7 +1,7 @@
 require 'net/ssh'
 
 class Hull::Node
-  attr_reader :name
+  attr_reader :name, :host
 
   def self.find(name)
     @nodes[name]
@@ -21,12 +21,15 @@ def initialize(name, host)
 
   def execute(cmd)
     log('execute', cmd.cyan)
+    output = ""
     connection.exec! cmd do |channel, stream, data|
+      output += data if stream == :stdout
       data.split("\n").each do |line|
         msg = stream == :stdout ? line.green : line.red
         log(stream, msg)
       end
     end
+    output
   end
 
   def log(context, msg)

lib/hull/package.rb

@@ -9,12 +9,18 @@ def initialize(name)
     @remove = nil
   end
 
-  def depends_on(pkg_name)
-    @dependancies << pkg_name
+  def depends_on(*pkg_names)
+    pkg_names.each do |pkg_name|
+      @dependancies << pkg_name
+    end
   end
 
-  def install(&definition)
-    @commands[:install] = definition
+  def validate(&definition)
+    @commands[:validate] = definition
+  end
+
+  def apply(&definition)
+    @commands[:apply] = definition
   end
 
   def remove(&definition)

lib/hull/package_index.rb

@@ -16,7 +16,22 @@ def add(pkg)
 
   def get(pkg_name)
     pkg = @packages[pkg_name]
-    raise "Missing Package #{pkg_name}" if pkg.nil?
+    raise MissingPackageError.new(index_name, pkg_name) if pkg.nil?
     pkg
   end
+
+  def clear!
+    @packages = {}
+  end
+
+  class MissingPackageError < StandardError
+    def initialize(index_name, package_name)
+      @index_name = index_name
+      @package_name = package_name
+    end
+
+    def message
+      "package #{@package_name} could not be found in the index #{@index_name}"
+    end
+  end
 end

lib/hull/packages/apt.rb

@@ -1,4 +1,14 @@
 module Hull::DSL
+  def apt_package(pkg_name, apt_name=pkg_name, &blk)
+    package pkg_name do
+      depends_on 'apt'
+      validate { trigger 'apt:exists', apt_name  }
+      apply    { trigger 'apt:install', apt_name }
+      remove   { trigger 'apt:remove', apt_name  }
+      instance_eval(&blk) if blk
+    end
+  end
+
   package 'apt' do
     action 'install' do |package_name|
       run "DEBIAN_FRONTEND=noninteractive apt-get install -y -q #{package_name}"
@@ -7,5 +17,33 @@ module Hull::DSL
     action 'remove' do |package_name|
       run "DEBIAN_FRONTEND=noninteractive apt-get remove -y -q #{package_name}"
     end
+
+    action 'ppa' do |repo|
+      run "DEBIAN_FRONTEND=noninteractive add-apt-repository #{repo} -y"
+    end
+
+    action 'update' do
+      run "DEBIAN_FRONTEND=noninteractive apt-get update -y -qq"
+    end
+
+    action 'exists' do |package_name|
+      run("dpkg -s #{package_name} 2>&1 | grep Status") =~ /Status: install ok installed/
+    end
+
+    validate do
+      trigger('apt:exists', 'python-software-properties') &&
+      trigger('apt:exists', 'software-properties-common')
+    end
+
+    apply do
+      trigger 'apt:install', 'python-software-properties'
+      trigger 'apt:install', 'software-properties-common'
+      trigger 'apt:update'
+    end
+
+    remove do
+      trigger 'apt:remove', 'python-software-properties'
+      trigger 'apt:remove', 'software-properties-common'
+    end
   end
 end

lib/hull/packages/gem.rb

@@ -0,0 +1,24 @@
+module Hull::DSL
+  def gem_package(pkg_name, gem_name=pkg_name)
+    package pkg_name do
+      depends_on 'gem' # should depend on Ruby but which???
+      validate { trigger 'gem:exists', gem_name  }
+      apply    { trigger 'gem:install', gem_name }
+      remove   { trigger 'gem:remove', gem_name  }
+    end
+  end
+
+  package 'gem' do
+    action 'exists' do |gem_name|
+      run("gem list -i #{gem_name}") =~ /true/
+    end
+
+    action 'install' do |gem_name|
+      run "gem install #{gem_name} --no-ri --no-rdoc"
+    end
+
+    action 'remove' do |gem_name|
+      run "gem uninstall #{gem_name} -x -a"
+    end
+  end
+end

lib/hull/resolver.rb

@@ -0,0 +1,25 @@
+class Hull::Resolver
+  attr_reader :packages, :tree
+  def initialize(package)
+    @package = package
+    @last_seen = package
+    @tree = [@package]
+    @packages = []
+  end
+
+  def resolve
+    dependancies = @package.dependancies.map { |d| Hull::PackageIndex.default.get(d) }
+    begin
+      @tree += dependancies.map {|d| Hull::Resolver.new(d).resolve.tree }
+    rescue SystemStackError
+      raise CircularDependancyError.new
+    end
+    @packages = @tree.flatten
+    @packages.reverse!
+    @packages.uniq!
+    self
+  end
+
+  class CircularDependancyError < StandardError
+  end
+end

lib/hull/runner.rb

@@ -11,65 +11,42 @@ def packages
     resolver.packages
   end
 
-  def apply(command_name)
+  def execute(command_name)
+    @node.log command_name, packages.map(&:name).join(', ').yellow
     packages.each do |pkg|
-      next unless pkg.provides_command?(command_name)
-      @node.log pkg.name, command_name.to_s.yellow
-      context = @perform ? Hull::ExecutionContext.new(@node) : Hull::MockExecutionContext.new(@node)
-      cmd = pkg.command(command_name)
-      context.apply(cmd)
+      next unless should_run?(pkg, command_name)
+      exec(pkg, command_name)
+      validate!(pkg) if command_name == :apply
     end
   end
 
-  def demonstrate(command_name)
-    @perform = false
-    apply(command_name)
-    @perform = true
-  end
-end
-
-
-class Hull::ExecutionContext
-  def initialize(node)
-    @node = node
-  end
-
-  def apply(blk)
-    instance_eval(&blk)
+  def should_run?(pkg, command_name)
+    return false unless pkg.provides_command?(command_name)
+    return true unless @perform
+    return true unless command_name == :apply || command_name == :remove
+    return true unless pkg.provides_command?(:validate)
+    is_present = exec(pkg, :validate)
+    return !is_present if command_name == :apply
+    return is_present
   end
 
-  def run(cmd)
-    @node.execute(cmd)
+  def validate!(pkg)
+    return true unless @perform
+    return unless pkg.provides_command?(:validate)
+    return if exec(pkg, :validate)
+    raise "Package #{pkg.name} failed validation"
   end
 
-  def trigger(action, *args)
-    pkg_name, action_name = *action.split(':', 2)
-    pkg = Hull::PackageIndex.default.get(pkg_name)
-    action = pkg.actions[action_name]
-    instance_exec(*args, &action)
-  end
-end
-
-class Hull::MockExecutionContext < Hull::ExecutionContext
-  def run(cmd)
-    @node.log 'mock-execute', cmd
-  end
-end
-
-
-class Hull::Resolver
-  attr_reader :packages
-  def initialize(package)
-    @package = package
-    @packages = [@package]
+  def demonstrate(command_name)
+    @perform = false
+    apply(command_name)
+    @perform = true
   end
 
-  def resolve
-    dependancies = @package.dependancies.map { |d| Hull::PackageIndex.default.get(d) }
-    @packages += dependancies.map {|d| Hull::Resolver.new(d).resolve.packages }
-    @packages.flatten!
-    @packages.reverse!
-    @packages.uniq!
-    self
+  def exec(pkg, command_name)
+    @node.log pkg.name, command_name.to_s.yellow
+    context = @perform ? Hull::ExecutionContext.new(@node) : Hull::MockExecutionContext.new(@node)
+    cmd = pkg.command(command_name)
+    context.apply(cmd)
   end
 end

test/dsl_test.rb

@@ -0,0 +1,35 @@
+require_relative 'test_helper'
+
+describe Hull::DSL do
+  describe "'package' command" do
+    after :each do
+      reset_package_index!
+    end
+
+    it "adds a package to the index" do
+      Hull::DSL.package('my-package') { nil }
+      Hull::PackageIndex.default.get('my-package').must_be_instance_of Hull::Package
+    end
+
+    it "creates a new package based on the supplied name" do
+      Hull::DSL.package('my-package') { nil }
+      package = Hull::PackageIndex.default.get('my-package')
+      package.name.must_equal 'my-package'
+    end
+
+    it "executes the given definition block in the package context" do
+      Hull::DSL.package('my-package') { depends_on 'other-package' }
+      package = Hull::PackageIndex.default.get('my-package')
+      package.dependancies.must_equal ['other-package']
+    end
+  end
+
+  describe "'node' command" do
+    it "creates a node and adds it to the index" do
+      Hull::DSL.node('node-name', 'node-host')
+      node = Hull::Node.find('node-name')
+      node.name.must_equal 'node-name'
+      node.host.must_equal 'node-host'
+    end
+  end
+end

test/package_index_test.rb

@@ -0,0 +1,48 @@
+require_relative 'test_helper'
+
+describe Hull::PackageIndex do
+  before :each do
+    @package = Hull::Package.new('my-package')
+    @default = Hull::PackageIndex.default
+  end
+
+  after :each do
+    reset_package_index!
+  end
+
+  describe "default" do
+    it "returns a package index singleton named default" do
+      Hull::PackageIndex.default.index_name.must_equal 'default'
+    end
+
+    it "allways returns the same package index" do
+      Hull::PackageIndex.default.must_equal Hull::PackageIndex.default
+    end
+  end
+
+  describe "add" do
+    it "adds a package to the index" do
+      @default.add(@package)
+      @default.get(@package.name).must_equal @package
+    end
+  end
+
+  describe 'get' do
+    it "fetches a package by name" do
+      @default.add(@package)
+      @default.get(@package.name).must_equal @package
+    end
+
+    it "throws an execption if the package doesn't exist" do
+      assert_raises(Hull::PackageIndex::MissingPackageError) { @default.get(@package.name) }
+    end
+  end
+
+  describe "clear!" do
+    it "wipes the index clean of packages" do
+      @default.add(@package)
+      @default.clear!
+      assert_raises(Hull::PackageIndex::MissingPackageError) { @default.get(@package.name) }
+    end
+  end
+end

test/package_test.rb

@@ -0,0 +1,51 @@
+require_relative 'test_helper'
+
+describe Hull::Package do
+  before :each do
+    @package = Hull::Package.new('my-package')
+  end
+
+  describe "depends_on" do
+    it "adds a dependancy" do
+      @package.dependancies.must_equal []
+      @package.depends_on('other-package')
+      @package.dependancies.must_equal ['other-package']
+    end
+
+    it "adds multiple dependancies at once" do
+      @package.dependancies.must_equal []
+      @package.depends_on('other-package', 'third-package')
+      @package.dependancies.must_equal ['other-package', 'third-package']
+    end
+  end
+
+  describe "action" do
+    it "allows defining actions with a name and a block" do
+      @package.action('my-action') { 'foo' }
+      @package.actions['my-action'].call.must_equal 'foo'
+    end
+  end
+
+  describe "commands" do
+    it "can add an 'apply' command" do
+      @package.apply { 'my-apply' }
+      @package.command(:apply).call.must_equal 'my-apply'
+    end
+
+    it "can add an 'remove' command" do
+      @package.remove { 'my-remove' }
+      @package.command(:remove).call.must_equal 'my-remove'
+    end
+
+    it "can add an 'validate' command" do
+      @package.validate { 'my-validate' }
+      @package.command(:validate).call.must_equal 'my-validate'
+    end
+
+    it 'knows if a command is provided' do
+      @package.provides_command?(:apply).must_equal false
+      @package.apply { 'my-apply' }
+      @package.provides_command?(:apply).must_equal true
+    end
+  end
+end

test/resolver_test.rb

@@ -0,0 +1,61 @@
+require_relative 'test_helper'
+
+describe Hull::Resolver do
+  before :each do
+    @pkg_a = Hull::DSL.package('a') {}
+    @pkg_b = Hull::DSL.package('b') {}
+    @pkg_c = Hull::DSL.package('c') {}
+    @pkg_d = Hull::DSL.package('d') {}
+  end
+
+  after :each do
+    reset_package_index!
+  end
+
+  describe "resolving a tree of package dependancies" do
+    it "resolves single packages to a single package" do
+      resolver = Hull::Resolver.new(@pkg_a)
+      resolver.resolve
+      resolver.packages.must_equal [@pkg_a]
+    end
+
+    it "resolves a chain of 2 packages to a list of 2 packages" do
+      @pkg_a.depends_on(@pkg_b.name)
+      resolver = Hull::Resolver.new(@pkg_a)
+      resolver.resolve
+      resolver.packages.must_equal [@pkg_b, @pkg_a]
+    end
+
+    it "resolves a chain of 3 packages to a list of 3 packages" do
+      @pkg_a.depends_on(@pkg_b.name)
+      @pkg_b.depends_on(@pkg_c.name)
+      resolver = Hull::Resolver.new(@pkg_a)
+      resolver.resolve
+      resolver.packages.must_equal [@pkg_c, @pkg_b, @pkg_a]
+    end
+
+    it "resolves a tree of 3 packages to a list of 3 packages" do
+      @pkg_a.depends_on(@pkg_b.name)
+      @pkg_a.depends_on(@pkg_c.name)
+      resolver = Hull::Resolver.new(@pkg_a)
+      resolver.resolve
+      resolver.packages.must_equal [@pkg_c, @pkg_b, @pkg_a]
+    end
+
+    it "resolves a tree of 4 packages to a list of 4 packages" do
+      @pkg_a.depends_on(@pkg_b.name)
+      @pkg_a.depends_on(@pkg_c.name)
+      @pkg_c.depends_on(@pkg_d.name)
+      resolver = Hull::Resolver.new(@pkg_a)
+      resolver.resolve
+      resolver.packages.must_equal [@pkg_d, @pkg_c, @pkg_b, @pkg_a]
+    end
+
+    it "errors out on circular dependancies" do
+      @pkg_a.depends_on(@pkg_b.name)
+      @pkg_b.depends_on(@pkg_a.name)
+      resolver = Hull::Resolver.new(@pkg_a)
+      assert_raises(Hull::Resolver::CircularDependancyError) { resolver.resolve }
+    end
+  end
+end

test/test_helper.rb

@@ -0,0 +1,9 @@
+gem 'minitest'
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'mocha/setup'
+require_relative '../lib/hull'
+
+def reset_package_index!
+  Hull::PackageIndex.default.clear!
+end