vagrant-cucumber 0.0.1

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.0.1 (June 12, 2013)
+
+Initial release - supports Virtualbox and VMWare Fusion

data/README.md

@@ -0,0 +1,116 @@
+Vagrant Cucumber
+================
+
+Description
+-----------
+
+This plugin allows Vagrant to run cucumber features, and provides some glue
+for working with vagrant boxes within your cucumber steps.
+
+It was originally developed to help us test configuration management scripts,
+and with the following workflow in mind:
+
+ * Start one or more Vagrant boxes
+ * Configure these boxes with some default state
+ * Snapshot each box in this default state.
+ * In each cucumber scenario
+    - Run config management tools inside the box to make configuration changes
+    - Test that these changes produce the desired result
+    - Roll the VM state back, ready for the next scenario
+
+
+Requirements
+------------
+
+The plugin requires cucumber and vagrant-zz-multiprovider-snap gems, but will
+install these itself if required.
+
+Vagrant Cucumber currently works only with the current Vagrant providers:
+
+ * VirtualBox
+ * VMWare Fusion (using the commercial VMWare plugin for Vagrant)
+
+
+
+Installation
+------------
+
+Assuming you're running the packaged version of Vagrant, the easiest way to 
+install this plugin is via the published gem:
+
+```
+vagrant plugin install vagrant-cucumber
+```
+
+As well as the vagrant-cucumber plugin, this will also install the
+vagrant-zz-multiprovider-snap plugin if you don't already have it.
+
+vagrant-cucumber will also install a version of cucumber >= 1.3.2 under the
+Ruby environment provided by Vagrant.
+
+
+Usage
+-----
+
+This plugin adds a subcommand, ```vagrant cucumber``` - this simply wraps
+the usual ```cucumber``` commandline handler - refer to the documentation for
+cucumber for details, or use ```vagrant cucumber -h``` for a full list of
+options.
+
+
+Example
+-------
+
+The git source of the plugin includes a folder called "example", which contains
+a Vagrantfile and features directory which demonstrates the plugin in action.
+
+The Vagrantfile defines two basic VMs which will be used to run our tests.
+It will work with either the Virtualbox or the VMWare Fusion provider.
+
+Use ```vagrant up``` in that folder in order to start the default VM. (In the
+current version of the plugin, VMs must be running before they can be used
+in tests).  If you don't already have the standard precise64 vagrant box, it 
+will be fetched from the Vagrant website.  If you prefer to use the VMWare
+provider, add ```--provider=vmware_fusion``` to the commandline.
+
+To run all the tests, run 
+
+```vagrant cucumber```.
+
+The tests are split between multiple feature files. You can run one feature 
+file at a time by specifying it on the commandline:
+
+```vagrant cucumber features/basic.feature```
+
+```basic.feature``` demonstrates running basic shell commands inside the VM
+both as the standard vagrant user, and as root.  It also contains a test to show
+that snapshot rollback is working correctly.  
+
+```multivm.feature``` shows how steps can reference different VMs.  For details
+on how to write your own step definitions which can work on multiple VMs,
+see the next section.
+
+The test in ```multivm.feature``` also demonstrates use of cucumber tags.
+The test scenario is preceded with the tag ```@vagrant-cucumber-debug```. This
+causes debug output to be emitted.
+
+We also provide a ```@norollback``` tag, which prevents the VMs from being
+rolled back at the end of the scenario.  This is useful for debugging.
+
+
+
+Implementation Detail
+---------------------
+
+The best place to gain an understanding of the implementation of Cucumber steps
+is in ```example/features/step_definitions/process.rb```.  I've heavily
+commented this in order to be a good working example.
+
+```example/features/process.feature``` uses these step definitions.
+
+Other step definitions and hooks are defined in ```lib/vagrant-cucumber/step_definitions.rb```.
+
+
+
+
+

data/example/Vagrantfile

@@ -0,0 +1,19 @@
+Vagrant.configure("2") do |config|
+
+    config.vm.box     = "precise64"
+    config.vm.box_url = "http://files.vagrantup.com/precise64.box"
+
+    config.vm.provider :vmware_fusion do |fusion,override|
+        override.vm.box     = "precise64_vmware_fusion"
+        override.vm.box_url = "http://files.vagrantup.com/precise64_vmware_fusion.box"
+    end
+
+    config.vm.define :vm1 do |vm1|
+        vm1.vm.hostname = 'vm1'
+    end
+
+    config.vm.define :vm2 do |vm2|
+        vm2.vm.hostname = 'vm2'
+    end
+
+end

data/example/features/basic.feature

@@ -0,0 +1,32 @@
+Feature: VM Running
+
+    Scenario: Check we can run simple commands
+
+        Given there is a running VM called "vm1"
+        Then running the shell command `id` should succeed
+        And the stdout of that shell command should match /vagrant/
+        And the stdout of that shell command should not match /root/
+        And the stderr of that shell command should match /^$/
+
+
+    Scenario: Check we can run commands as root
+
+        Given there is a running VM called "vm1"
+        Then running the shell command `id` as root should succeed
+        And the stdout of that shell command should match /root/
+        And the stdout of that shell command should not match /vagrant/
+
+
+    Scenario: Write a file so that we can check we're rolling back properly
+
+        Given there is a running VM called "vm1"
+
+        Then running the shell command `grep test /tmp/cucumber-written-file` should fail
+
+        When I run the shell command `echo test > /tmp/cucumber-written-file`, it should succeed
+        And running the shell command `grep test /tmp/cucumber-written-file` should succeed
+
+        When I roll back the VM called "vm1"
+        Then running the shell command `grep test /tmp/cucumber-written-file` should fail
+
+

data/example/features/multivm.feature

@@ -0,0 +1,18 @@
+Feature: Testing on multiple VMs
+
+    @vagrant-cucumber-debug
+    Scenario: Check we can run simple commands on multiple VMs
+
+        Given there is a running VM called "vm1"
+        And there is a running VM called "vm2"
+
+        # The following four steps are equivalent
+        Then running the shell command `hostname` on the VM called "vm1" should succeed
+        Then running the shell command `hostname` on the VM "vm1" should succeed
+        And running the shell command `hostname` on the last VM should succeed
+        And running the shell command `hostname` should succeed
+
+        And running the shell command `hostname` on the VM "vm2" should succeed
+
+
+

data/example/features/process.feature

@@ -0,0 +1,9 @@
+Feature: Check to see if processes are running in the VM
+
+    Scenario: Check that init is running
+        Given there is a running VM called "vm1"
+        Then there should be a process called "init" running
+
+    Scenario: Check that non-existant process check also works
+        Given there is a running VM called "vm1"
+        Then there should not be a process called "i-dont-exist" running

data/example/features/step_definitions/process.rb

@@ -0,0 +1,77 @@
+# Cucumber step definitions are defined like function definitions, and start 
+# with a preposition or adverb (Given, When, Then, And, But).
+# 
+# The regular expression defined will be matched against steps in the feature
+# files when cucumber runs.  The matched groups in the regex will be passed
+# in order as variables to the block.  In this case, the three groups are 
+# assigned to "condition", "process_name" and "vmre"
+#
+# More information on step definitions can be found at
+# https://github.com/cucumber/cucumber/wiki/Step-Definitions
+
+Then /there should(| not) be a process called "([^"]*)" running(#{VMRE})$/ do |condition, process_name, vmre|
+
+    # First, we work out what virtual machine we're going to be dealing with
+    # in this step.  The VMRE variable in the regex above is defined by
+    # vagrant-cucumber to match various English-language ways in which we
+    # might refer to a vagrant box:
+    #
+    #  String matched                  VM identified
+    #  -------------------------------------------------------------------
+    #  ''                              Last referenced
+    #  'on the last VM'                Last referenced
+    #  'on the VM "<vmname>"'          Named <vmname>
+    #  'on the VM called "<vmname>"'   Named <vmname>
+    #
+    #  The call to vagrant_glue.identified_vm returns a Vagrant::Machine
+    #  object to the relevant VM.
+
+    machine = vagrant_glue.identified_vm(vmre)
+
+
+    # Now we use the machine's communication interface (probably ssh, though
+    # this is provider-dependent) to execute a shell command inside the VM.
+
+    machine.communicate.tap do |comm|
+
+        rv = comm.execute( 
+            "pidof #{process_name}", { 
+                :error_check => false, # stop vagrant throwing an exception
+            }                          # if the command returns non-zero
+            
+        ) do |type,data|
+
+            # Execute takes a block, which is yielded to whenever there's
+            # output on stdout or stderr.  We handle any output in this block.
+            #
+            # In this case, we'll put all output onto stdout, but only if
+            # @vagrant_cucumber_debug has been set.  This class variable will
+            # be set to true in the Before hook defined in 
+            # lib/vagrant-cucumber/step_definitions.rb
+
+            if @vagrant_cucumber_debug
+                puts "[:#{type}] #{data.chomp}"
+            end
+
+        end
+
+        # Output the status from the command if we're in debugging mode
+        if @vagrant_cucumber_debug
+            puts "Exit status of pidof command: #{rv}"
+        end
+
+        # Cucumber steps are expected to exit cleanly if they worked ok, and
+        # raise exceptions if they fail.  The following logic implements
+        # the conditions in which we want to fail the step.
+
+        if rv != 0 and condition == ''
+            raise "There was no proces called #{process_name} running on #{machine.name}"
+        end
+
+        if rv == 0 and condition == ' not'
+            raise "There was a process called #{process_name} running on #{machine.name}"
+        end
+
+    end
+
+end

data/example/features/support/env.rb

@@ -0,0 +1,3 @@
+require 'vagrant-cucumber/step_definitions'
+
+World( VagrantPlugins::Cucumber::Glue )

data/lib/vagrant-cucumber/commands/cucumber.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+    module Cucumber
+        class CucumberCommand < Vagrant.plugin(2, :command)
+
+            def execute
+
+                require 'cucumber/rspec/disable_option_parser'
+                require 'cucumber/cli/main'
+
+                require 'vagrant-cucumber/cucumber/formatter/pretty'
+                require 'vagrant-cucumber/cucumber/formatter/html'
+
+                failure = ::Cucumber::Cli::Main.execute(@argv)    
+
+            end
+
+        end
+    end
+end
+

data/lib/vagrant-cucumber/cucumber/formatter/html.rb

@@ -0,0 +1,24 @@
+require 'cucumber/formatter/html'
+
+module VagrantPlugins
+
+    module Cucumber
+
+        module Formatter
+
+            class Html < ::Cucumber::Formatter::Html
+
+                def puts(message)
+                    # TODO Strip ansi escape codes
+                    @delayed_messages << message
+                end
+
+            end 
+
+        end
+
+    end
+
+end
+
+

data/lib/vagrant-cucumber/cucumber/formatter/pretty.rb

@@ -0,0 +1,33 @@
+require 'cucumber/formatter/pretty'
+
+module VagrantPlugins
+
+    module Cucumber
+
+        module Formatter
+
+            class Pretty < ::Cucumber::Formatter::Pretty
+
+                # Use the Pretty formatter, but disable use of
+                #  delayed messages (ie. output each line at once)
+
+                def initialize(*args)
+                    super
+                    @delayed_messages = nil
+                end
+
+                # print_messages is only used to output the delayed_messages
+                #  and fails because of the above hack, so make it a noop
+
+                def print_messages
+                end
+
+            end
+
+        end
+
+    end
+
+end
+
+

data/lib/vagrant-cucumber/glue.rb

@@ -0,0 +1,99 @@
+unless defined?(VMRE)
+    VMRE = /(?: on the last VM| on the VM(?: called|) "(?:[^"]+)"|)/
+end
+
+module VagrantPlugins
+
+    module Cucumber
+
+        module Glue
+
+            # This glue module will be used in the cucumber World for
+            #  tests run with vagrant-cucumber.  It's used to hide interaction
+            #  with the messier parts of the vagrant environment so the
+            #  step definitions don't need to care about them.
+
+            def vagrant_glue
+                VagrantGlue.instance
+            end
+
+            class VagrantGlue
+
+                def initialize
+
+                    @vagrant_env = Vagrant::Environment.new(
+                        :ui_class => Vagrant::UI::Basic
+                    )
+
+                    @last_machine_mentioned = nil
+
+                end
+
+                def self.instance
+                    return @@instance ||= VagrantGlue.new
+                end
+
+                def vagrant_env
+                    @vagrant_env
+                end
+
+                def get_last_vm
+                    get_vm( @last_machine_mentioned )
+                end
+
+                def get_vm( vmname )
+
+                    machine_provider = nil
+                    machine_name     = nil
+
+                    # If this machine name is not configured, blow up
+                    if ! @vagrant_env.machine_names.index(vmname.to_sym)
+                        raise Vagrant::Errors::VMNotFoundError, :name => vmname
+                    end
+
+                    @vagrant_env.active_machines.each do |a_name, a_provider|
+
+                        if a_name == vmname.to_sym
+                            machine_provider = a_provider
+                            machine_name     = a_name
+                        end
+
+                    end
+
+                    if !machine_name
+
+                        raise "The VM '#{vmname}' is configured in the Vagrantfile "+
+                            "but has not been started.  Run 'vagrant up #{vmname}' and "+
+                            "specify a provider if necessary."
+
+                    end
+
+                    machine_provider ||= vagrant_env.default_provider
+                    machine = @vagrant_env.machine( 
+                        machine_name, machine_provider
+                    )
+
+                    @last_machine_mentioned = vmname
+
+                    machine
+
+                end
+
+                def identified_vm( str )
+                    case str
+                        when /^( on the last VM|)$/
+                            get_last_vm
+                        when /^ on the VM(?: called|) "([^"]+)"$/
+                            get_vm( $1 )
+                    end
+                end
+
+            end
+
+
+        end
+
+    end
+
+end
+

data/lib/vagrant-cucumber/plugin.rb

@@ -0,0 +1,24 @@
+begin
+    require "vagrant"
+rescue LoadError
+    raise "The Vagrant Cucumber plugin must be run within Vagrant."
+end
+
+module VagrantPlugins
+    module Cucumber 
+        class Plugin < Vagrant.plugin("2")
+
+            name "Cucumber"
+
+            description <<-DESC
+            This plugin makes it possible for Cucumber to interact with Vagrant
+            DESC
+
+            command "cucumber" do
+                require_relative "commands/cucumber"
+                CucumberCommand
+            end
+
+        end
+    end
+end

data/lib/vagrant-cucumber/step_definitions.rb

@@ -0,0 +1,106 @@
+require 'to_regexp'
+
+Given /^there is a running VM called "([^"]*)"$/ do |vmname|
+
+    machine = vagrant_glue.get_vm( vmname )
+
+    machine.action(:up)
+
+    unless machine.provider.driver.has_snapshot?
+        machine.action(:snapshot_take)
+    end
+
+end
+
+When /^I roll back the VM called "([^"]*)"$/ do |vmname|
+
+    machine = vagrant_glue.get_vm( vmname )
+    vagrant_glue.vagrant_env.cli('snap', 'rollback', vmname )
+
+end
+
+Then /^(?:running|I run) the shell command `(.*)`(| as root)(#{VMRE})(?:|, it) should (succeed|fail)$/ do |command,as_root,vmre,condition|
+
+    @last_shell_command_output = {
+        :stdout => '',
+        :stderr => '',
+    }
+
+    @last_shell_command_status = nil
+
+    machine = vagrant_glue.identified_vm(vmre)
+    machine.communicate.tap do |comm|
+
+        @last_shell_command_status = comm.execute( 
+            command, { 
+                :error_check => false,
+                :sudo        => as_root == ' as root',
+            } 
+        ) do |type,data|
+
+            if @vagrant_cucumber_debug
+                puts "[:#{type}] #{data.chomp}"
+            end
+
+            @last_shell_command_output[type] += data
+
+        end 
+
+    end
+
+    if @last_shell_command_status == 0 and condition == 'fail'
+        raise "Expected command to fail, but got 0 exit status"
+    end
+
+    if @last_shell_command_status != 0 and condition == 'succeed'
+        raise "Expected command to succeed but got #{@last_shell_command_status} exit status"
+    end
+
+end
+
+Then /^the (.+) of that shell command should(| not) match (\/.+\/)$/ do |stream,condition,re|
+
+    stream.downcase!
+
+    unless @last_shell_command_output.has_key?( stream.to_sym )
+        raise "@last_shell_command_output structure has no #{stream}"
+    end
+
+    re_result = ( @last_shell_command_output[stream.to_sym] =~ re.to_regexp )
+    re_matched = !re_result.nil?
+
+    should_match = condition != ' not'
+
+    if re_matched and !should_match
+        raise "Regular expression matched, but shouldn't have"
+    end
+
+    if !re_matched and should_match
+        raise "Regular expression didn't match, but should have"
+    end
+
+end
+
+Before('@norollback') do |scenario|
+    puts "Saw @norollback tag:"
+    puts "  * Won't roll back snapshot at end of scenario"
+    puts "  * Will roll back explicit snapshots in the scenario"
+end
+
+
+
+After('~@norollback') do |scenario|
+
+    puts "Rolling back VM states"
+    vagrant_glue.vagrant_env.cli('snap', 'rollback' )
+
+end
+
+After('@norollback') do |scenario|
+    puts "Saw @norollback tag - not rolling back"
+end
+
+Before('@vagrant-cucumber-debug') do |scenario|
+    puts "Enabling debugging for vagrant-cucumber scenarios"
+    @vagrant_cucumber_debug = true
+end

data/lib/vagrant-cucumber/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Cucumber
+    VERSION = "0.0.1"
+  end
+end

data/lib/vagrant-cucumber.rb

@@ -0,0 +1,9 @@
+require "vagrant-cucumber/version"
+require "vagrant-cucumber/plugin"
+require "vagrant-cucumber/glue"
+
+module VagrantPlugins
+  module Cucumber
+    # ... 
+  end
+end

data/vagrant-cucumber.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "vagrant-cucumber/version"
+
+Gem::Specification.new do |s|
+  s.name        = "vagrant-cucumber"
+  s.version     = VagrantPlugins::Cucumber::VERSION
+  s.authors     = ["Jon Topper"]
+  s.email       = ["jon@scalefactory.com"]
+  s.homepage    = "https://github.com/scalefactory/vagrant-cucumber"
+  s.summary     = %q{Cucumber support for Vagrant}
+  s.description = %q{This plugin makes it possible for Cucumber to interact with Vagrant}
+
+  s.rubyforge_project = "vagrant-cucumber"
+
+  files = `git ls-files`.split("\n")
+  ignore = %w{Gemfile Rakefile .gitignore}
+
+  files.delete_if do |f|
+      ignore.any? do |i|
+          File.fnmatch(i, f, File::FNM_PATHNAME) ||
+          File.fnmatch(i, File.basename(f), File::FNM_PATHNAME)
+      end
+  end
+  
+  s.add_runtime_dependency "cucumber", ">=1.3.2"
+  s.add_runtime_dependency "vagrant-zz-multiprovider-snap", ">=0.0.3"
+
+  s.files         = files
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-cucumber
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jon Topper
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: &70146505916660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70146505916660
+- !ruby/object:Gem::Dependency
+  name: vagrant-zz-multiprovider-snap
+  requirement: &70146505916160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *70146505916160
+description: This plugin makes it possible for Cucumber to interact with Vagrant
+email:
+- jon@scalefactory.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- example/Vagrantfile
+- example/features/basic.feature
+- example/features/multivm.feature
+- example/features/process.feature
+- example/features/step_definitions/process.rb
+- example/features/support/env.rb
+- lib/vagrant-cucumber.rb
+- lib/vagrant-cucumber/commands/cucumber.rb
+- lib/vagrant-cucumber/cucumber/formatter/html.rb
+- lib/vagrant-cucumber/cucumber/formatter/pretty.rb
+- lib/vagrant-cucumber/glue.rb
+- lib/vagrant-cucumber/plugin.rb
+- lib/vagrant-cucumber/step_definitions.rb
+- lib/vagrant-cucumber/version.rb
+- vagrant-cucumber.gemspec
+homepage: https://github.com/scalefactory/vagrant-cucumber
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: vagrant-cucumber
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Cucumber support for Vagrant
+test_files: []