Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Refactor acceptance tests to use util library

This commit adds utility methods to "temp_file_utils.rb"
and refactors all the tests that were duplicating these
utility methods to use this library code instead.
  • Loading branch information...
commit 2e225f46ee6d54f2dc584a8c357eb17a5d08602a 1 parent 16ac654
@cprice404 cprice404 authored
View
12 acceptance/lib/puppet/acceptance/temp_file_utils.rb
@@ -50,12 +50,22 @@ def get_test_file_path(host, file_rel_path)
# tests to be written using only a relative path to specify file locations, while still taking advantage
# of automatic temp file cleanup at test completion.
def test_file_exists?(host, file_rel_path)
- host.execute("test -f \"#{get_test_file_path(host, file_rel_path)}\"",
+ file_exists?(host, get_test_file_path(host, file_rel_path))
+ end
+
+ def file_exists?(host, file_path)
+ host.execute("test -f \"#{file_path}\"",
:acceptable_exit_codes => [0, 1]) do |result|
return result.exit_code == 0
end
end
+ def file_contents(host, file_path)
+ host.execute("cat \"#{file_path}\"") do |result|
+ return result.stdout
+ end
+ end
+
def tmpdir(host, basename)
host_tmpdir = host.tmpdir(basename)
# we need to make sure that the puppet user can traverse this directory...
View
242 acceptance/pending/pluginsync/7316_faces_should_be_available_via_pluginsync.rb
@@ -1,242 +0,0 @@
-test_name "the pluginsync functionality should sync app definitions, and they should be runnable afterwards"
-
-#
-# This test is intended to ensure that pluginsync syncs face definitions to the agents.
-# Further, the face should be runnable on the agent after the sync has occurred.
-#
-# (NOTE: When this test is passing, it should resolve both #7316 re: verifying that apps/faces can
-# be run on the agent node after a plugin sync, and #6753 re: being able to run a face without
-# having a placeholder stub file in the "applications" directory.)
-#
-
-###############################################################################
-# BEGIN UTILITY METHODS - ideally this stuff would live somewhere besides in
-# the actual test.
-###############################################################################
-
-# Create a file on the host.
-# Parameters:
-# [host] the host to create the file on
-# [file_path] the path to the file to be created
-# [file_content] a string containing the contents to be written to the file
-# [options] a hash containing additional behavior options. Currently supported:
-# * :mkdirs (default false) if true, attempt to create the parent directories on the remote host before writing
-# the file
-# * :owner (default 'root') the username of the user that the file should be owned by
-# * :group (default 'puppet') the name of the group that the file should be owned by
-# * :mode (default '644') the mode (file permissions) that the file should be created with
-def create_test_file(host, file_rel_path, file_content, options)
-
- # set default options
- options[:mkdirs] ||= false
- options[:owner] ||= "root"
- options[:group] ||= "puppet"
- options[:mode] ||= "755"
-
- file_path = get_test_file_path(host, file_rel_path)
-
- mkdirs(host, File.dirname(file_path)) if (options[:mkdirs] == true)
- create_remote_file(host, file_path, file_content)
-
-#
-# NOTE: we need these chown/chmod calls because the acceptance framework connects to the nodes as "root", but
-# puppet 'master' runs as user 'puppet'. Therefore, in order for puppet master to be able to read any files
-# that we've created, we have to carefully set their permissions
-#
-
- chown(host, options[:owner], options[:group], file_path)
- chmod(host, options[:mode], file_path)
-
-end
-
-
-# Given a relative path, returns an absolute path for a test file. Basically, this just prepends the
-# a unique temp dir path (specific to the current test execution) to your relative path.
-def get_test_file_path(host, file_rel_path)
- File.join(@host_test_tmp_dirs[host.name], file_rel_path)
-end
-
-
-# Check for the existence of a temp file for the current test; basically, this just calls file_exists?(),
-# but prepends the path to the current test's temp dir onto the file_rel_path parameter. This allows
-# tests to be written using only a relative path to specify file locations, while still taking advantage
-# of automatic temp file cleanup at test completion.
-def test_file_exists?(host, file_rel_path)
- host.execute("test -f \"#{get_test_file_path(host, file_rel_path)}\"",
- :acceptable_exit_codes => [0, 1]) do |result|
- return result.exit_code == 0
- end
-end
-
-def tmpdir(host, basename)
- host_tmpdir = host.tmpdir(basename)
- # we need to make sure that the puppet user can traverse this directory...
- chmod(host, "755", host_tmpdir)
- host_tmpdir
-end
-
-def mkdirs(host, dir_path)
- on(host, "mkdir -p #{dir_path}")
-end
-
-def chown(host, owner, group, path)
- on(host, "chown #{owner}:#{group} #{path}")
-end
-
-def chmod(host, mode, path)
- on(host, "chmod #{mode} #{path}")
-end
-
-
-
-
-# pluck this out of the test case environment; not sure if there is a better way
-cur_test_file = @path
-cur_test_file_shortname = File.basename(cur_test_file, File.extname(cur_test_file))
-
-# we need one list of all of the hosts, to assist in managing temp dirs. It's possible
-# that the master is also an agent, so this will consolidate them into a unique set
-all_hosts = Set[master, *agents]
-
-# now we can create a hash of temp dirs--one per host, and unique to this test--without worrying about
-# doing it twice on any individual host
-@host_test_tmp_dirs = Hash[all_hosts.map do |host| [host.name, tmpdir(host, cur_test_file_shortname)] end ]
-
-# a silly variable for keeping track of whether or not all of the tests passed...
-all_tests_passed = false
-
-###############################################################################
-# END UTILITY METHODS
-###############################################################################
-
-
-
-###############################################################################
-# BEGIN TEST LOGIC
-###############################################################################
-
-# create some vars to point to the directories that we're going to point the master/agents at
-master_module_dir = "master_modules"
-agent_lib_dir = "agent_lib"
-
-app_name = "superbogus"
-app_desc = "a simple %1$s for testing %1$s delivery via plugin sync"
-app_output = "Hello from the #{app_name} %s"
-
-master_module_file_content = {}
-
-
-master_module_file_content["face"] = <<-HERE
-Puppet::Face.define(:#{app_name}, '0.0.1') do
- copyright "Puppet Labs", 2011
- license "Apache 2 license; see COPYING"
-
- summary "#{app_desc % "face"}"
-
- action(:foo) do
- summary "a test action defined in the test face in the main puppet lib dir"
-
- default
- when_invoked do |*args|
- puts "#{app_output % "face"}"
- end
- end
-
-end
-HERE
-
-
-
-# this begin block is here for handling temp file cleanup via an "ensure" block at the very end of the
-# test.
-begin
-
- modes = ["face"]
-
- modes.each do |mode|
-
- # here we create a custom app, which basically doesn't do anything except for print a hello-world message
- agent_module_app_file = "#{agent_lib_dir}/puppet/#{mode}/#{app_name}.rb"
- master_module_app_file = "#{master_module_dir}/#{app_name}/lib/puppet/#{mode}/#{app_name}.rb"
-
-
- # copy all the files to the master
- step "write our simple module out to the master" do
- create_test_file(master, master_module_app_file, master_module_file_content[mode], :mkdirs => true)
- end
-
- step "verify that the app file exists on the master" do
- unless test_file_exists?(master, master_module_app_file) then
- fail_test("Failed to create app file '#{get_test_file_path(master, master_module_app_file)}' on master")
- end
- end
-
- step "start the master" do
- with_master_running_on(master,
- "--modulepath=\"#{get_test_file_path(master, master_module_dir)}\"") do
-
- # the module files shouldn't exist on the agent yet because they haven't been synced
- step "verify that the module files don't exist on the agent path" do
- agents.each do |agent|
- if test_file_exists?(agent, agent_module_app_file) then
- fail_test("app file already exists on agent: '#{get_test_file_path(agent, agent_module_app_file)}'")
- end
- end
- end
-
- step "run the agent" do
- agents.each do |agent|
- run_agent_on(agent, "--trace --libdir=\"#{get_test_file_path(agent, agent_lib_dir)}\" " +
- "--no-daemonize --verbose --onetime --test --server #{master}")
- end
- end
-
- end
- end
-
- step "verify that the module files were synced down to the agent" do
- agents.each do |agent|
- unless test_file_exists?(agent, agent_module_app_file) then
- fail_test("Expected app file not synced to agent: '#{get_test_file_path(agent, agent_module_app_file)}'")
- end
- end
- end
-
- step "verify that the application shows up in help" do
- agents.each do |agent|
- on(agent, PuppetCommand.new(:help, "--libdir=\"#{get_test_file_path(agent, agent_lib_dir)}\"")) do
- assert_match(/^\s+#{app_name}\s+#{app_desc % mode}$/, result.stdout)
- end
- end
- end
-
- step "verify that we can run the application" do
- agents.each do |agent|
- on(agent, PuppetCommand.new(:"#{app_name}", "--libdir=\"#{get_test_file_path(agent, agent_lib_dir)}\"")) do
- assert_match(/^#{app_output % mode}$/, result.stdout)
- end
- end
- end
-
- step "clear out the libdir on the agents in preparation for the next test" do
- agents.each do |agent|
- on(agent, "rm -rf #{get_test_file_path(agent, agent_module_app_file)}/*")
- end
- end
-
- end
-
- all_tests_passed = true
-
-ensure
- ##########################################################################################
- # Clean up all of the temp files created by this test. It would be nice if this logic
- # could be handled outside of the test itself; I envision a stanza like this one appearing
- # in a very large number of the tests going forward unless it is handled by the framework.
- ##########################################################################################
- if all_tests_passed then
- all_hosts.each do |host|
- on(host, "rm -rf #{@host_test_tmp_dirs[host.name]}")
- end
- end
-end
View
113 acceptance/tests/agent/agent_disable_lockfile.rb
@@ -7,117 +7,14 @@
# in terms of actually restricting or allowing new agent runs to begin.
#
-###############################################################################
-# BEGIN UTILITY METHODS - ideally this stuff would live somewhere besides in
-# the actual test.
-###############################################################################
-
-# Create a file on the host.
-# Parameters:
-# [host] the host to create the file on
-# [file_path] the path to the file to be created
-# [file_content] a string containing the contents to be written to the file
-# [options] a hash containing additional behavior options. Currently supported:
-# * :mkdirs (default false) if true, attempt to create the parent directories on the remote host before writing
-# the file
-# * :owner (default 'root') the username of the user that the file should be owned by
-# * :group (default 'puppet') the name of the group that the file should be owned by
-# * :mode (default '644') the mode (file permissions) that the file should be created with
-def create_test_file(host, file_rel_path, file_content, options)
-
- # set default options
- options[:mkdirs] ||= false
- options[:owner] ||= "root"
- options[:group] ||= "puppet"
- options[:mode] ||= "755"
-
- file_path = get_test_file_path(host, file_rel_path)
-
- mkdirs(host, File.dirname(file_path)) if (options[:mkdirs] == true)
- create_remote_file(host, file_path, file_content)
-
-#
-# NOTE: we need these chown/chmod calls because the acceptance framework connects to the nodes as "root", but
-# puppet 'master' runs as user 'puppet'. Therefore, in order for puppet master to be able to read any files
-# that we've created, we have to carefully set their permissions
-#
-
- chown(host, options[:owner], options[:group], file_path)
- chmod(host, options[:mode], file_path)
-
-end
+require 'puppet/acceptance/temp_file_utils'
-# Given a relative path, returns an absolute path for a test file. Basically, this just prepends the
-# a unique temp dir path (specific to the current test execution) to your relative path.
-def get_test_file_path(host, file_rel_path)
- File.join(@host_test_tmp_dirs[host.name], file_rel_path)
-end
-
-
-# Check for the existence of a temp file for the current test; basically, this just calls file_exists?(),
-# but prepends the path to the current test's temp dir onto the file_rel_path parameter. This allows
-# tests to be written using only a relative path to specify file locations, while still taking advantage
-# of automatic temp file cleanup at test completion.
-def test_file_exists?(host, file_rel_path)
- file_exists?(host, get_test_file_path(host, file_rel_path))
-end
-
-def file_exists?(host, file_path)
- host.execute("test -f \"#{file_path}\"",
- :acceptable_exit_codes => [0, 1]) do |result|
- return result.exit_code == 0
- end
-end
-
-def file_contents(host, file_path)
- host.execute("cat \"#{file_path}\"") do |result|
- return result.stdout
- end
-end
-
-def tmpdir(host, basename)
- host_tmpdir = host.tmpdir(basename)
- # we need to make sure that the puppet user can traverse this directory...
- chmod(host, "755", host_tmpdir)
- host_tmpdir
-end
+extend Puppet::Acceptance::TempFileUtils
-def mkdirs(host, dir_path)
- on(host, "mkdir -p #{dir_path}")
-end
-
-def chown(host, owner, group, path)
- on(host, "chown #{owner}:#{group} #{path}")
-end
-
-def chmod(host, mode, path)
- on(host, "chmod #{mode} #{path}")
-end
-
-
-
-
-# pluck this out of the test case environment; not sure if there is a better way
-cur_test_file = @path
-cur_test_file_shortname = File.basename(cur_test_file, File.extname(cur_test_file))
-
-# we need one list of all of the hosts, to assist in managing temp dirs. It's possible
-# that the master is also an agent, so this will consolidate them into a unique set
-all_hosts = Set[master, *agents]
-
-# now we can create a hash of temp dirs--one per host, and unique to this test--without worrying about
-# doing it twice on any individual host
-@host_test_tmp_dirs = Hash[all_hosts.map do |host| [host.name, tmpdir(host, cur_test_file_shortname)] end ]
-
-# a silly variable for keeping track of whether or not all of the tests passed...
+initialize_temp_dirs()
all_tests_passed = false
-###############################################################################
-# END UTILITY METHODS
-###############################################################################
-
-
###############################################################################
# BEGIN TEST LOGIC
@@ -202,8 +99,6 @@ def chmod(host, mode, path)
# in a very large number of the tests going forward unless it is handled by the framework.
##########################################################################################
if all_tests_passed then
- all_hosts.each do |host|
- on(host, "rm -rf #{@host_test_tmp_dirs[host.name]}")
- end
+ remove_temp_dirs()
end
end
View
6 acceptance/tests/pluginsync/7316_apps_should_be_available_via_pluginsync.rb
@@ -7,12 +7,12 @@
require 'puppet/acceptance/temp_file_utils'
-class << self
- include Puppet::Acceptance::TempFileUtils
-end
+extend Puppet::Acceptance::TempFileUtils
initialize_temp_dirs()
+all_tests_passed = false
+
###############################################################################
# BEGIN TEST LOGIC
###############################################################################
View
105 acceptance/tests/pluginsync/7316_faces_with_app_stubs_should_be_available_via_pluginsync.rb
@@ -9,109 +9,14 @@
# having a placeholder stub file in the "applications" directory.)
#
-###############################################################################
-# BEGIN UTILITY METHODS - ideally this stuff would live somewhere besides in
-# the actual test.
-###############################################################################
-
-# Create a file on the host.
-# Parameters:
-# [host] the host to create the file on
-# [file_path] the path to the file to be created
-# [file_content] a string containing the contents to be written to the file
-# [options] a hash containing additional behavior options. Currently supported:
-# * :mkdirs (default false) if true, attempt to create the parent directories on the remote host before writing
-# the file
-# * :owner (default 'root') the username of the user that the file should be owned by
-# * :group (default 'puppet') the name of the group that the file should be owned by
-# * :mode (default '644') the mode (file permissions) that the file should be created with
-def create_test_file(host, file_rel_path, file_content, options)
-
- # set default options
- options[:mkdirs] ||= false
- options[:owner] ||= "root"
- options[:group] ||= "puppet"
- options[:mode] ||= "755"
-
- file_path = get_test_file_path(host, file_rel_path)
-
- mkdirs(host, File.dirname(file_path)) if (options[:mkdirs] == true)
- create_remote_file(host, file_path, file_content)
-
-#
-# NOTE: we need these chown/chmod calls because the acceptance framework connects to the nodes as "root", but
-# puppet 'master' runs as user 'puppet'. Therefore, in order for puppet master to be able to read any files
-# that we've created, we have to carefully set their permissions
-#
-
- chown(host, options[:owner], options[:group], file_path)
- chmod(host, options[:mode], file_path)
-
-end
+require 'puppet/acceptance/temp_file_utils'
+extend Puppet::Acceptance::TempFileUtils
-# Given a relative path, returns an absolute path for a test file. Basically, this just prepends the
-# a unique temp dir path (specific to the current test execution) to your relative path.
-def get_test_file_path(host, file_rel_path)
- File.join(@host_test_tmp_dirs[host.name], file_rel_path)
-end
-
-
-# Check for the existence of a temp file for the current test; basically, this just calls file_exists?(),
-# but prepends the path to the current test's temp dir onto the file_rel_path parameter. This allows
-# tests to be written using only a relative path to specify file locations, while still taking advantage
-# of automatic temp file cleanup at test completion.
-def test_file_exists?(host, file_rel_path)
- host.execute("test -f \"#{get_test_file_path(host, file_rel_path)}\"",
- :acceptable_exit_codes => [0, 1]) do |result|
- return result.exit_code == 0
- end
-end
-
-def tmpdir(host, basename)
- host_tmpdir = host.tmpdir(basename)
- # we need to make sure that the puppet user can traverse this directory...
- chmod(host, "755", host_tmpdir)
- host_tmpdir
-end
-
-def mkdirs(host, dir_path)
- on(host, "mkdir -p #{dir_path}")
-end
-
-def chown(host, owner, group, path)
- on(host, "chown #{owner}:#{group} #{path}")
-end
-
-def chmod(host, mode, path)
- on(host, "chmod #{mode} #{path}")
-end
-
-
-
-
-# pluck this out of the test case environment; not sure if there is a better way
-cur_test_file = @path
-cur_test_file_shortname = File.basename(cur_test_file, File.extname(cur_test_file))
-
-# we need one list of all of the hosts, to assist in managing temp dirs. It's possible
-# that the master is also an agent, so this will consolidate them into a unique set
-all_hosts = Set[master, *agents]
-
-# now we can create a hash of temp dirs--one per host, and unique to this test--without worrying about
-# doing it twice on any individual host
-@host_test_tmp_dirs = Hash[all_hosts.map do |host| [host.name, tmpdir(host, cur_test_file_shortname)] end ]
-
-# a silly variable for keeping track of whether or not all of the tests passed...
+initialize_temp_dirs()
all_tests_passed = false
###############################################################################
-# END UTILITY METHODS
-###############################################################################
-
-
-
-###############################################################################
# BEGIN TEST LOGIC
###############################################################################
@@ -251,8 +156,6 @@ class Puppet::Application::#{app_name.capitalize} < Puppet::Application::FaceBas
# in a very large number of the tests going forward unless it is handled by the framework.
##########################################################################################
if all_tests_passed then
- all_hosts.each do |host|
- on(host, "rm -rf #{@host_test_tmp_dirs[host.name]}")
- end
+ remove_temp_dirs()
end
end
View
116 acceptance/tests/pluginsync/apply_should_sync_plugins.rb
@@ -1,119 +1,14 @@
test_name "puppet apply should pluginsync"
-###############################################################################
-# BEGIN UTILITY METHODS - ideally this stuff would live somewhere besides in
-# the actual test.
-###############################################################################
-# Create a file on the host.
-# Parameters:
-# [host] the host to create the file on
-# [file_path] the path to the file to be created
-# [file_content] a string containing the contents to be written to the file
-# [options] a hash containing additional behavior options. Currently supported:
-# * :mkdirs (default false) if true, attempt to create the parent directories on the remote host before writing
-# the file
-# * :owner (default 'root') the username of the user that the file should be owned by
-# * :group (default 'puppet') the name of the group that the file should be owned by
-# * :mode (default '644') the mode (file permissions) that the file should be created with
-def create_test_file(host, file_rel_path, file_content, options)
+require 'puppet/acceptance/temp_file_utils'
- # set default options
- options[:mkdirs] ||= false
- options[:owner] ||= "root"
- options[:group] ||= "puppet"
- options[:mode] ||= "755"
+extend Puppet::Acceptance::TempFileUtils
- file_path = get_test_file_path(host, file_rel_path)
+initialize_temp_dirs()
- mkdirs(host, File.dirname(file_path)) if (options[:mkdirs] == true)
- create_remote_file(host, file_path, file_content)
-
-#
-# NOTE: we need these chown/chmod calls because the acceptance framework connects to the nodes as "root", but
-# puppet 'master' runs as user 'puppet'. Therefore, in order for puppet master to be able to read any files
-# that we've created, we have to carefully set their permissions
-#
-
- chown(host, options[:owner], options[:group], file_path)
- chmod(host, options[:mode], file_path)
-
-end
-
-
-# Given a relative path, returns an absolute path for a test file. Basically, this just prepends the
-# a unique temp dir path (specific to the current test execution) to your relative path.
-def get_test_file_path(host, file_rel_path)
- File.join(@host_test_tmp_dirs[host.name], file_rel_path)
-end
-
-
-# Check for the existence of a temp file for the current test; basically, this just calls file_exists?(),
-# but prepends the path to the current test's temp dir onto the file_rel_path parameter. This allows
-# tests to be written using only a relative path to specify file locations, while still taking advantage
-# of automatic temp file cleanup at test completion.
-def test_file_exists?(host, file_rel_path)
- file_exists?(host, get_test_file_path(host, file_rel_path))
-end
-
-def file_exists?(host, file_path)
- host.execute("test -f \"#{file_path}\"",
- :acceptable_exit_codes => [0, 1]) do |result|
- return result.exit_code == 0
- end
-end
-
-def file_contents(host, file_path)
- host.execute("cat \"#{file_path}\"") do |result|
- return result.stdout
- end
-end
-
-def tmpdir(host, basename)
- host_tmpdir = host.tmpdir(basename)
- # we need to make sure that the puppet user can traverse this directory...
- chmod(host, "755", host_tmpdir)
- host_tmpdir
-end
-
-def mkdirs(host, dir_path)
- on(host, "mkdir -p #{dir_path}")
-end
-
-def chown(host, owner, group, path)
- if host['platform'].include?('windows')
- return;
- end
- on(host, "chown #{owner}:#{group} #{path}")
-end
-
-def chmod(host, mode, path)
- on(host, "chmod #{mode} #{path}")
-end
-
-
-
-
-# pluck this out of the test case environment; not sure if there is a better way
-cur_test_file = @path
-cur_test_file_shortname = File.basename(cur_test_file, File.extname(cur_test_file))
-
-# we need one list of all of the hosts, to assist in managing temp dirs. It's possible
-# that the master is also an agent, so this will consolidate them into a unique set
-all_hosts = Set[master, *agents]
-
-# now we can create a hash of temp dirs--one per host, and unique to this test--without worrying about
-# doing it twice on any individual host
-@host_test_tmp_dirs = Hash[all_hosts.map do |host| [host.name, tmpdir(host, cur_test_file_shortname)] end ]
-
-# a silly variable for keeping track of whether or not all of the tests passed...
all_tests_passed = false
-###############################################################################
-# END UTILITY METHODS
-###############################################################################
-
-
step "Create some modules in the modulepath"
basedir = 'tmp_acceptance_pluginsync_modules'
@@ -132,6 +27,7 @@ def chmod(host, mode, path)
assert_match(/#1a/, stdout, "The synced plugin was not found or the wrong version was synced")
end
end
+ all_tests_passed = true
ensure
##########################################################################################
@@ -140,8 +36,6 @@ def chmod(host, mode, path)
# in a very large number of the tests going forward unless it is handled by the framework.
##########################################################################################
if all_tests_passed then
- all_hosts.each do |host|
- on(host, "rm -rf #{@host_test_tmp_dirs[host.name]}")
- end
+ remove_temp_dirs()
end
end
View
105 acceptance/tests/pluginsync/feature/pluginsync_should_sync_features.rb
@@ -8,109 +8,14 @@
#
+require 'puppet/acceptance/temp_file_utils'
-###############################################################################
-# BEGIN UTILITY METHODS - ideally this stuff would live somewhere besides in
-# the actual test.
-###############################################################################
-
-# Create a file on the host.
-# Parameters:
-# [host] the host to create the file on
-# [file_path] the path to the file to be created
-# [file_content] a string containing the contents to be written to the file
-# [options] a hash containing additional behavior options. Currently supported:
-# * :mkdirs (default false) if true, attempt to create the parent directories on the remote host before writing
-# the file
-# * :owner (default 'root') the username of the user that the file should be owned by
-# * :group (default 'puppet') the name of the group that the file should be owned by
-# * :mode (default '644') the mode (file permissions) that the file should be created with
-def create_test_file(host, file_rel_path, file_content, options)
-
- # set default options
- options[:mkdirs] ||= false
- options[:owner] ||= "root"
- options[:group] ||= "puppet"
- options[:mode] ||= "755"
-
- file_path = get_test_file_path(host, file_rel_path)
-
- mkdirs(host, File.dirname(file_path)) if (options[:mkdirs] == true)
- create_remote_file(host, file_path, file_content)
-
-#
-# NOTE: we need these chown/chmod calls because the acceptance framework connects to the nodes as "root", but
-# puppet 'master' runs as user 'puppet'. Therefore, in order for puppet master to be able to read any files
-# that we've created, we have to carefully set their permissions
-#
-
- chown(host, options[:owner], options[:group], file_path)
- chmod(host, options[:mode], file_path)
-
-end
+extend Puppet::Acceptance::TempFileUtils
+initialize_temp_dirs()
-# Given a relative path, returns an absolute path for a test file. Basically, this just prepends the
-# a unique temp dir path (specific to the current test execution) to your relative path.
-def get_test_file_path(host, file_rel_path)
- File.join(@host_test_tmp_dirs[host.name], file_rel_path)
-end
-
-
-# Check for the existence of a temp file for the current test; basically, this just calls file_exists?(),
-# but prepends the path to the current test's temp dir onto the file_rel_path parameter. This allows
-# tests to be written using only a relative path to specify file locations, while still taking advantage
-# of automatic temp file cleanup at test completion.
-def test_file_exists?(host, file_rel_path)
- host.execute("test -f \"#{get_test_file_path(host, file_rel_path)}\"",
- :acceptable_exit_codes => [0, 1]) do |result|
- return result.exit_code == 0
- end
-end
-
-def tmpdir(host, basename)
- host_tmpdir = host.tmpdir(basename)
- # we need to make sure that the puppet user can traverse this directory...
- chmod(host, "755", host_tmpdir)
- host_tmpdir
-end
-
-def mkdirs(host, dir_path)
- on(host, "mkdir -p #{dir_path}")
-end
-
-def chown(host, owner, group, path)
- on(host, "chown #{owner}:#{group} #{path}")
-end
-
-def chmod(host, mode, path)
- on(host, "chmod #{mode} #{path}")
-end
-
-
-
-
-
-# pluck this out of the test case environment; not sure if there is a better way
-cur_test_file = @path
-cur_test_file_shortname = File.basename(cur_test_file, File.extname(cur_test_file))
-
-# we need one list of all of the hosts, to assist in managing temp dirs. It's possible
-# that the master is also an agent, so this will consolidate them into a unique set
-all_hosts = Set[master, *agents]
-
-# now we can create a hash of temp dirs--one per host, and unique to this test--without worrying about
-# doing it twice on any individual host
-@host_test_tmp_dirs = Hash[all_hosts.map do |host| [host.name, tmpdir(host, cur_test_file_shortname)] end ]
-
-# a silly variable for keeping track of whether or not all of the tests passed...
all_tests_passed = false
-###############################################################################
-# END UTILITY METHODS
-###############################################################################
-
-
###############################################################################
# BEGIN TEST LOGIC
@@ -277,9 +182,7 @@ def insync?(is)
# in a very large number of the tests going forward unless it is handled by the framework.
##########################################################################################
if all_tests_passed then
- all_hosts.each do |host|
- on(host, "rm -rf #{@host_test_tmp_dirs[host.name]}")
- end
+ remove_temp_dirs()
end
end
View
112 acceptance/tests/ticket_13948_lib_dir_hook_should_be_called_on_initialization.rb
@@ -1,117 +1,15 @@
test_name "the $libdir setting hook is called on startup"
-#
-# This test is intended to ensure that pluginsync syncs face definitions to the agents.
-# Further, the face should be runnable on the agent after the sync has occurred.
-#
-# (NOTE: When this test is passing, it should resolve both #7316 re: verifying that apps/faces can
-# be run on the agent node after a plugin sync, and #6753 re: being able to run a face without
-# having a placeholder stub file in the "applications" directory.)
-#
-
-###############################################################################
-# BEGIN UTILITY METHODS - ideally this stuff would live somewhere besides in
-# the actual test.
-###############################################################################
-
-# Create a file on the host.
-# Parameters:
-# [host] the host to create the file on
-# [file_path] the path to the file to be created
-# [file_content] a string containing the contents to be written to the file
-# [options] a hash containing additional behavior options. Currently supported:
-# * :mkdirs (default false) if true, attempt to create the parent directories on the remote host before writing
-# the file
-# * :owner (default 'root') the username of the user that the file should be owned by
-# * :group (default 'puppet') the name of the group that the file should be owned by
-# * :mode (default '644') the mode (file permissions) that the file should be created with
-def create_test_file(host, file_rel_path, file_content, options)
-
- # set default options
- options[:mkdirs] ||= false
- options[:owner] ||= "root"
- options[:group] ||= "puppet"
- options[:mode] ||= "755"
-
- file_path = get_test_file_path(host, file_rel_path)
-
- mkdirs(host, File.dirname(file_path)) if (options[:mkdirs] == true)
- create_remote_file(host, file_path, file_content)
-
-#
-# NOTE: we need these chown/chmod calls because the acceptance framework connects to the nodes as "root", but
-# puppet 'master' runs as user 'puppet'. Therefore, in order for puppet master to be able to read any files
-# that we've created, we have to carefully set their permissions
-#
-
- chown(host, options[:owner], options[:group], file_path)
- chmod(host, options[:mode], file_path)
-
-end
-
-
-# Given a relative path, returns an absolute path for a test file. Basically, this just prepends the
-# a unique temp dir path (specific to the current test execution) to your relative path.
-def get_test_file_path(host, file_rel_path)
- File.join(@host_test_tmp_dirs[host.name], file_rel_path)
-end
-
-
-# Check for the existence of a temp file for the current test; basically, this just calls file_exists?(),
-# but prepends the path to the current test's temp dir onto the file_rel_path parameter. This allows
-# tests to be written using only a relative path to specify file locations, while still taking advantage
-# of automatic temp file cleanup at test completion.
-def test_file_exists?(host, file_rel_path)
- host.execute("test -f \"#{get_test_file_path(host, file_rel_path)}\"",
- :acceptable_exit_codes => [0, 1]) do |result|
- return result.exit_code == 0
- end
-end
-
-def tmpdir(host, basename)
- host_tmpdir = host.tmpdir(basename)
- # we need to make sure that the puppet user can traverse this directory...
- chmod(host, "755", host_tmpdir)
- host_tmpdir
-end
-
-def mkdirs(host, dir_path)
- on(host, "mkdir -p #{dir_path}")
-end
-
-def chown(host, owner, group, path)
- on(host, "chown #{owner}:#{group} #{path}")
-end
-
-def chmod(host, mode, path)
- on(host, "chmod #{mode} #{path}")
-end
-
-
-# pluck this out of the test case environment; not sure if there is a better way
-cur_test_file = @path
-cur_test_file_shortname = File.basename(cur_test_file, File.extname(cur_test_file))
+require 'puppet/acceptance/temp_file_utils'
-# we need one list of all of the hosts, to assist in managing temp dirs. It's possible
-# that the master is also an agent, so this will consolidate them into a unique set
-all_hosts = Set[master, *agents]
+extend Puppet::Acceptance::TempFileUtils
-# now we can create a hash of temp dirs--one per host, and unique to this test--without worrying about
-# doing it twice on any individual host
-@host_test_tmp_dirs = Hash[all_hosts.map do |host| [host.name, tmpdir(host, cur_test_file_shortname)] end ]
-
-# a silly variable for keeping track of whether or not all of the tests passed...
+initialize_temp_dirs()
all_tests_passed = false
###############################################################################
-# END UTILITY METHODS
-###############################################################################
-
-
-
-###############################################################################
# BEGIN TEST LOGIC
###############################################################################
@@ -252,8 +150,6 @@ class Puppet::Application::#{app_name.capitalize} < Puppet::Application::FaceBas
# in a very large number of the tests going forward unless it is handled by the framework.
##########################################################################################
if all_tests_passed then
- all_hosts.each do |host|
- on(host, "rm -rf #{@host_test_tmp_dirs[host.name]}")
- end
+ remove_temp_dirs()
end
end
Please sign in to comment.
Something went wrong with that request. Please try again.