engineyard-jenkins 0.4.0

data/features/step_definitions/api_steps.rb

@@ -0,0 +1,10 @@
+Given /^I have setup my engineyard email\/password for API access$/ do
+  ENV['EYRC'] = File.join(@home_path, ".eyrc")
+  token = { ENV['CLOUD_URL'] => {
+      "api_token" => "f81a1706ddaeb148cfb6235ddecfc1cf"} }
+  File.open(ENV['EYRC'], "w"){|f| YAML.dump(token, f) }
+end
+
+When /^I have "two accounts, two apps, two environments, ambiguous"$/ do
+  api_scenario "two accounts, two apps, two environments, ambiguous"
+end

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,211 @@
+Given /^this project is active project folder/ do
+  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
+end
+
+Given /^env variable \$([\w_]+) set to( project path|) "(.*)"/ do |env_var, path, value|
+  in_project_folder {
+    value = File.expand_path(value)
+  } unless path.empty?
+  ENV[env_var] = value
+end
+
+Given /"(.*)" folder is deleted/ do |folder|
+  in_project_folder { FileUtils.rm_rf folder }
+end
+
+When /^I invoke "(.*)" generator with arguments "(.*)"$/ do |generator, arguments|
+  @stdout = StringIO.new
+  in_project_folder do
+    if Object.const_defined?("APP_ROOT")
+      APP_ROOT.replace(FileUtils.pwd)
+    else
+      APP_ROOT = FileUtils.pwd
+    end
+    run_generator(generator, arguments.split(' '), SOURCES, :stdout => @stdout)
+  end
+  File.open(File.join(@tmp_root, "generator.out"), "w") do |f|
+    @stdout.rewind
+    f << @stdout.read
+  end
+end
+
+When /^I run executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "#{executable.inspect} #{arguments} > #{@stdout.inspect} 2> #{@stdout.inspect}"
+  end
+end
+
+When /^I run project executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "ruby -rubygems #{executable.inspect} #{arguments} > #{@stdout.inspect} 2> #{@stdout.inspect}"
+  end
+end
+
+When /^I run local executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  if executable == "ey-jenkins"
+    require 'engineyard-jenkins'
+    require 'engineyard-jenkins/cli'
+    in_project_folder do
+      stdout, stderr = capture_stdios do
+        Engineyard::Jenkins::CLI.start(arguments.split(/ /))
+      end
+      @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+      File.open(@stdout, "w") {|f| f << stdout; f << stderr}
+    end
+  else
+    @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+    executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin", executable))
+    in_project_folder do
+      system "ruby -rubygems #{executable.inspect} #{arguments} > #{@stdout.inspect} 2> #{@stdout.inspect}"
+    end
+  end
+end
+
+When /^I invoke task "rake (.*)"/ do |task|
+  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
+  in_project_folder do
+    system "bundle exec rake #{task} --trace > #{@stdout.inspect} 2> #{@stdout.inspect}"
+  end
+end
+
+Then /^folder "(.*)" (is|is not) created/ do |folder, is|
+  in_project_folder do
+    File.exists?(folder).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file "(.*)" (is|is not) created/ do |file, is|
+  in_project_folder do
+    File.exists?(file).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file with name matching "(.*)" is created/ do |pattern|
+  in_project_folder do
+    Dir[pattern].should_not be_empty
+  end
+end
+
+Then /^file "(.*)" contents (does|does not) match \/(.*)\// do |file, does, regex|
+  in_project_folder do
+    actual_output = File.read(file)
+    (does == 'does') ?
+      actual_output.should(match(/#{regex}/)) :
+      actual_output.should_not(match(/#{regex}/))
+  end
+end
+
+Then /^file "([^"]*)" contains "([^"]*)"$/ do |file, text|
+  in_project_folder do
+    actual_output = File.read(file)
+    actual_output.should contain(text)
+  end
+end
+
+
+Then /gem file "(.*)" and generated file "(.*)" should be the same/ do |gem_file, project_file|
+  File.exists?(gem_file).should be_true
+  File.exists?(project_file).should be_true
+  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
+  project_file_contents = File.read(File.join(@active_project_folder, project_file))
+  project_file_contents.should == gem_file_contents
+end
+
+Then /^(does|does not) invoke generator "(.*)"$/ do |does_invoke, generator|
+  actual_output = get_command_output
+  does_invoke == "does" ?
+    actual_output.should(match(/dependency\s+#{generator}/)) :
+    actual_output.should_not(match(/dependency\s+#{generator}/))
+end
+
+Then /help options "(.*)" and "(.*)" are displayed/ do |opt1, opt2|
+  actual_output = get_command_output
+  actual_output.should match(/#{opt1}/)
+  actual_output.should match(/#{opt2}/)
+end
+
+Then /^I should see "([^\"]*)"$/ do |text|
+  actual_output = get_command_output
+  actual_output.should contain(text)
+end
+
+Then /^I should not see "([^\"]*)"$/ do |text|
+  actual_output =
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see$/ do |text|
+  actual_output = get_command_output
+  actual_output.should contain(text)
+end
+
+Then /^I should not see$/ do |text|
+  actual_output = get_command_output
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see exactly$/ do |text|
+  actual_output = get_command_output
+  actual_output.should == text
+end
+
+Then /^I should see all (\d+) tests pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
+  actual_output = get_command_output
+  actual_output.should match(expected)
+end
+
+Then /^I should see all (\d+) examples pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} examples?, 0 failures}
+  actual_output = get_command_output
+  actual_output.should match(expected)
+end
+
+Then /^yaml file "(.*)" contains (\{.*\})/ do |file, yaml|
+  in_project_folder do
+    yaml = eval yaml
+    YAML.load(File.read(file)).should == yaml
+  end
+end
+
+Then /^Rakefile can display tasks successfully/ do
+  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
+  in_project_folder do
+    system "rake -T > #{@stdout.inspect} 2> #{@stdout.inspect}"
+  end
+  actual_output = get_command_output
+  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
+end
+
+Then /^task "rake (.*)" is executed successfully/ do |task|
+  @stdout.should_not be_nil
+  actual_output = get_command_output
+  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
+  actual_output.should_not match(/Error/i)
+end
+
+Then /^gem spec key "(.*)" contains \/(.*)\// do |key, regex|
+  in_project_folder do
+    gem_file = Dir["pkg/*.gem"].first
+    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
+    spec_value = gem_spec.send(key.to_sym)
+    spec_value.to_s.should match(/#{regex}/)
+  end
+end
+
+Then /^the file "([^\"]*)" is a valid gemspec$/ do |filename|
+  spec = eval(File.read(filename))
+  spec.validate
+end
+
+When /^I create a new node with the following options on "http:\/\/(.+?):(\d+)":$/ do |host, port, table|
+  options = table.raw.inject({}) do |options, (key, value)|
+    options[(key.to_sym rescue key) || key] = value
+    options
+  end
+
+  Jenkins::Api.setup_base_url(:host => host, :port => port.to_i)
+  Jenkins::Api.add_node(options)
+end

data/features/step_definitions/fixture_project_steps.rb

@@ -0,0 +1,14 @@
+Given /^I am in the "([^\"]*)" project folder$/ do |project|
+  project_folder = File.expand_path(File.join(@fixtures_path, "projects", project))
+  in_tmp_folder do
+    FileUtils.cp_r(project_folder, project)
+    setup_active_project_folder(project)
+  end
+end
+
+Given /^I already have cookbooks installed$/ do
+  cookbooks_folder = File.expand_path(File.join(@fixtures_path, "cookbooks"))
+  in_project_folder do
+    FileUtils.cp_r(cookbooks_folder, ".")
+  end
+end

data/features/step_definitions/jenkins_steps.rb

@@ -0,0 +1,9 @@
+Given /^I want to fake out the boot sequence of Jenkins$/ do
+  base_path = File.join(File.dirname(__FILE__) + "/../../fixtures/jenkins_boot_sequence/")
+  FakeWeb.register_uri(:get, "http://app-master-hostname.compute-1.amazonaws.com/", [
+    {:body => File.read(base_path + "pre_jenkins_booting.html")},
+    {:body => File.read(base_path + "jenkins_booting.html")},
+    {:body => File.read(base_path + "jenkins_ready.html")}
+  ])
+end
+

data/features/support/common.rb

@@ -0,0 +1,51 @@
+module CommonHelpers
+  def get_command_output
+    strip_color_codes(File.read(@stdout)).chomp
+  end
+
+  def strip_color_codes(text)
+    text.gsub(/\e\[\d+m/, '')
+  end
+
+  def in_tmp_folder(&block)
+    FileUtils.chdir(@tmp_root, &block)
+  end
+
+  def in_project_folder(&block)
+    project_folder = @active_project_folder || @tmp_root
+    FileUtils.chdir(project_folder, &block)
+  end
+
+  def in_home_folder(&block)
+    FileUtils.chdir(@home_path, &block)
+  end
+
+  def force_local_lib_override(project_name = @project_name)
+    rakefile = File.read(File.join(project_name, 'Rakefile'))
+    File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
+      f << "$:.unshift('#{@lib_path}')\n"
+      f << rakefile
+    end
+  end
+
+  def setup_active_project_folder project_name
+    @active_project_folder = File.join(@tmp_root, project_name)
+    @project_name = project_name
+  end
+
+  # capture both [stdout, stderr] as well as stdin
+  def capture_stdios(input = nil, &block)
+    require 'stringio'
+    org_stdin, $stdin = $stdin, StringIO.new(input) if input
+    org_stdout, $stdout = $stdout, StringIO.new
+    org_stderr, $stderr = $stdout, StringIO.new
+    yield
+    return [$stdout.string, $stderr.string]
+  ensure
+    $stderr = org_stderr
+    $stdout = org_stdout
+    $stdin = org_stdin
+  end
+end
+  
+World(CommonHelpers)

data/features/support/engineyard.rb

@@ -0,0 +1,24 @@
+engineyard_loaded_path = $:.select { |path| path =~ %r|gems/engineyard-\d+| }.first
+EY_ROOT = engineyard_loaded_path.gsub(%r|/\w+$|,'')
+
+# helper to be stubbed out from engineyard spec_helper.rb
+def shared_examples_for(title)
+end
+
+support = Dir[File.join(EY_ROOT,'/spec/support/*.rb')]
+support.each{|helper| require helper }
+World(Spec::Helpers)
+
+require "fakeweb"
+
+Before do
+  ENV["NO_SSH"] = "true"
+  ENV['CLOUD_URL'] = EY.fake_awsm
+  FakeWeb.allow_net_connect = true
+end
+
+After do
+  ENV.delete('CLOUD_URL')
+  ENV.delete('EYRC')
+  ENV.delete('NO_SSH')
+end

data/features/support/env.rb

@@ -0,0 +1,14 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../../lib'))
+require 'bundler/setup'
+require 'engineyard-jenkins'
+
+Before do
+  @tmp_root      = File.dirname(__FILE__) + "/../../tmp"
+  @active_project_folder = @tmp_root
+  @home_path     = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path      = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  @fixtures_path = File.expand_path(File.dirname(__FILE__) + "/../../fixtures")
+  FileUtils.rm_rf   @tmp_root
+  FileUtils.mkdir_p @home_path
+  ENV['HOME'] = @home_path
+end

data/features/support/matchers.rb

@@ -0,0 +1,10 @@
+
+module Matchers
+  RSpec::Matchers.define :contain do |expected_text|
+    match do |text|
+      text.index expected_text
+    end
+  end
+end
+
+World(Matchers)

data/fixtures/cookbooks/main/recipes/default.rb

@@ -0,0 +1 @@
+require_recipe 'redis'

data/fixtures/jenkins_boot_sequence/jenkins_booting.html

@@ -0,0 +1 @@
+Please wait while Jenkins is getting ready to work

data/fixtures/jenkins_boot_sequence/jenkins_ready.html

@@ -0,0 +1 @@
+Jenkins is up!

data/fixtures/jenkins_boot_sequence/pre_jenkins_booting.html

@@ -0,0 +1 @@
+This is some page before the instance is launched.

data/fixtures/projects/rails/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.rb"
+
+gem "rake"

data/fixtures/projects/rails/Gemfile.lock

@@ -0,0 +1,10 @@
+GEM
+  remote: http://rubygems.rb/
+  specs:
+    rake (0.8.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake

data/fixtures/projects/rails/Rakefile

@@ -0,0 +1,4 @@
+desc "Default task runs tests"
+task :default do
+  puts "Tests ran successfully!"
+end

data/lib/engineyard-jenkins.rb

@@ -0,0 +1,4 @@
+module Engineyard
+  module Jenkins
+  end
+end

data/lib/engineyard-jenkins/appcloud_env.rb

@@ -0,0 +1,49 @@
+require "engineyard"
+require "engineyard/thor"
+require "engineyard/cli"
+require "engineyard/cli/ui"
+require "engineyard/error"
+module Engineyard
+  module Jenkins
+    class AppcloudEnv
+      include EY::UtilityMethods
+      
+      # Returns [environment, account] based on current .eyrc credentials and/or CLI options
+      # Returns [nil, nil] if no unique environment can be selected
+      def find_environments(options = {})
+        Thor::Base.shell = EY::CLI::UI
+        EY.ui = EY::CLI::UI.new
+        query_environments = options[:environment] ? [options[:environment]] : default_query_environments
+        query_environments.inject([]) do |envs, env_name|
+          begin
+            if environment = fetch_environment(env_name, options[:account])
+              clean_host_name(environment)
+              envs << [env_name, environment.account.name, environment]
+            end
+          rescue EY::NoEnvironmentError
+          rescue EY::MultipleMatchesError => e
+            # e.message looks something like:
+            # Multiple environments possible, please be more specific:
+            # 
+            #   jenkins # ey <command> --environment='jenkins' --account='drnic-demo'
+            #   jenkins # ey <command> --environment='jenkins' --account='rails-jenkins'
+            e.message.scan(/--environment='([^']+)' --account='([^']+)'/) do
+              envs << [$1, $2, nil]
+            end
+          end
+          envs
+        end
+      end
+      
+      def default_query_environments
+        %w[jenkins jenkins_server jenkins_production jenkins_server_production]
+      end
+      
+      # Currently the engineyard gem has badly formed URLs in its same data
+      # This method cleans app_master_hostname.compute-1.amazonaws.com -> app-master-hostname.compute-1.amazonaws.com
+      def clean_host_name(environment)
+        environment.instances.first.public_hostname.gsub!(/_/,'-') if environment.instances.first
+      end
+    end
+  end
+end