bard 1.9.6 → 2.0.0.beta

data/features/step_definitions/global_steps.rb

@@ -0,0 +1,56 @@
+Given /^a shared rails project$/ do
+  # TEARDOWN
+  Dir.foreach "#{ROOT}/tmp" do |file|
+    FileUtils.rm_rf("#{ROOT}/tmp/#{file}") unless %w(fixtures . ..).include? file
+  end
+
+  # SETUP
+  Dir.chdir ROOT
+  `cp -r tmp/fixtures/* tmp/`
+
+  Dir.chdir 'tmp'
+  @repos = {}
+  %w(development_a development_b staging production).each do |env|
+    @repos[env] = Grit::Repo.new env
+  end
+  Dir.chdir 'development_a'
+  @repo = @repos['development_a']
+  @env = { 'RAILS_ENV' => 'development', 'TESTING' => true }
+end
+
+Given /^I am in a subdirectory$/ do
+  FileUtils.mkdir "test_subdirectory"
+  Dir.chdir "test_subdirectory"
+end
+
+When /^I type "([^\"]*)"$/ do |command|
+  type command.sub /\b(bard)\b/, "#{ROOT}/bin/bard"
+end
+
+When /^on (\w+), (.*$)/ do |env, step|
+  old_env = @env['RAILS_ENV']
+  @env['RAILS_ENV'] = env if %w(staging production).include? env
+  Dir.chdir "#{ROOT}/tmp/#{env}" do
+    old_repo = @repo
+    @repo = @repos[env]
+    When step
+    @repo = old_repo
+  end
+  @env['RAILS_ENV'] = old_env
+end
+
+Then /^I should see the fatal error "([^\"]*)"$/ do |error_message|
+  @stderr.should include(error_message)
+end
+
+Then /^I should see the warning "([^\"]*)"$/ do |warning_message|
+  @stderr.should include(warning_message)
+end
+
+Then /^I should see "([^\"]*)"$/ do |message|
+  @stdout.should include(message)
+end
+
+Then /^debug$/ do
+  debugger
+end

data/features/step_definitions/podman_steps.rb

@@ -0,0 +1,23 @@
+Given /^a podman testcontainer is ready for bard$/ do
+  raise "Podman testcontainer failed to start" unless @podman_container && @podman_ssh_port
+end
+
+Given /^a remote file "([^\"]+)" exists in the test container$/ do |filename|
+  run_ssh("touch testproject/#{filename}").should be_true
+end
+
+Given /^a remote file "([^\"]+)" containing "([^\"]+)" exists in the test container$/ do |filename, content|
+  run_ssh("echo #{Shellwords.escape(content)} > testproject/#{filename}").should be_true
+end
+
+When /^I run bard "([^\"]+)" against the test container$/ do |command|
+  run_bard_against_container(command)
+end
+
+Then /^the bard command should succeed$/ do
+  @status.success?.should be_true
+end
+
+Then /^the bard output should include "([^\"]+)"$/ do |expected|
+  @stdout.should include(expected)
+end

data/features/step_definitions/rails_steps.rb

@@ -0,0 +1,44 @@
+Given /^a commit with a new migration$/ do
+  type "script/generate migration test_migration"
+  type "git add ."
+  type "git commit -am'added test migration.'"
+end
+
+Given /^a (\w+) database$/ do |env|
+  type "rake db:create RAILS_ENV=#{env} && rake db:migrate RAILS_ENV=#{env}"
+end
+
+Then /^the (\w+) database should include that migration$/ do |env|
+  db_version = type("rake db:version RAILS_ENV=#{env}")[/[0-9]{14}/]
+  migration_version = type("ls db/migrate/*_test_migration.rb")[/[0-9]{14}/]
+  db_version.should == migration_version
+end
+
+Given /^the test gem is not installed$/ do
+  type "gem uninstall rake-dotnet -v=0.0.1 -x"
+end
+
+Given /^a commit that adds the test gem as a dependency$/ do
+  file_inject "config/environment.rb", "
+Rails::Initializer.run do |config|", <<-RUBY
+  config.gem "rake-dotnet", :version => "0.0.1"
+RUBY
+  type "git add ."
+  type "git commit -am'added test gem dependency.'"
+end
+
+Then /^the test gem should be installed$/ do
+  type("gem list rake-dotnet").should include "rake-dotnet (0.0.1)"
+end
+
+Then /^passenger should have been restarted$/ do
+  File.exist?("tmp/restart.txt").should be_true
+end
+
+Given /^the "([^\"]+)" file includes "([^\"]+)"$/ do |file, contents|
+  file_append file, contents
+end
+
+Given /^the "([^\"]+)" file does not include "([^\"]+)"$/ do |file, contents|
+  gsub_file file, contents, ""
+end

data/features/step_definitions/submodule_steps.rb

@@ -0,0 +1,110 @@
+Given /^a submodule$/ do
+  Given 'on development_b, a commit with a new submodule'
+  Given 'on development_b, I type "bard push"'
+  Given 'I type "bard pull"'
+  @submodule_url = File.read(".gitmodules").match(/url = (.*)$/)[1]
+  @submodule_commit = type "git submodule status"
+end
+
+Given /^the submodule working directory is dirty$/ do
+  Dir.chdir "submodule" do
+    type "git checkout master"
+    type "echo 'submodule_update' > submodule_update"
+  end
+end
+
+Given /^a commit to the submodule$/ do
+  Dir.chdir "submodule" do
+    type "echo 'submodule_update' > submodule_update"
+    type "git add ."
+    type "git commit -am 'update in submodule'"
+  end
+end
+
+Given /^a commit with a new submodule$/ do
+  type "git submodule add #{ROOT}/tmp/submodule_a.git submodule"
+  type "git submodule update --init"
+  Dir.chdir "submodule" do
+    type "git checkout master"
+  end
+  type "git add ."
+  type "git commit -m 'added submodule'"
+end
+
+Given /^a commit with a submodule update$/ do
+  type "git checkout integration"
+  Dir.chdir "submodule" do
+    type "git checkout master"
+    type "echo 'submodule_update' > submodule_update"
+    type "git add ."
+    type "git commit -m 'update in submodule'"
+    type "git push origin HEAD"
+  end
+  type "git add ."
+  type "git commit -m 'updated submodule'"
+end
+
+Given /^a commit with a submodule url change$/ do
+  gsub_file ".gitmodules", "submodule_a.git", "submodule_b.git"
+  type "git add ."
+  type "git commit -m 'updated submodule url'"
+end
+
+Given /^I a commit a with a submodule deletion$/ do
+  type "rm .gitmodules"
+  type "rm -rf --cached submodule"
+  type "git add ."
+  type "git commit -am'removed submodule'"
+end
+
+Then /^there should be one new submodule$/ do
+  status = type "git submodule status"
+  status.should match /.[a-z0-9]{40} submodule/
+end
+
+Then /^the submodule branch should match the submodule origin branch$/ do
+  @submodule_url = File.read(".gitmodules").match(/url = (.*)$/)[1]
+  @submodule_commit = type "git submodule status"
+  @submodule_commit.should match %r( [a-z0-9]{40} submodule)
+  Dir.chdir "submodule" do
+    @submodule = Grit::Repo.new "."
+    branch = @submodule.head.name rescue nil
+    remote_branch = @submodule.remotes.find {|n| n.name == "origin/HEAD" }.commit.id[/\w+$/]
+    branch.should_not be_nil
+    remote_branch.should_not be_nil
+    branch.should == remote_branch
+    type("git rev-parse HEAD").should == type("git rev-parse origin/HEAD")
+    type("git name-rev --name-only HEAD").should == type("git name-rev --name-only origin/HEAD")
+  end
+end
+
+Then /^the submodule should be checked out$/ do
+  @submodule_url = File.read(".gitmodules").match(/url = (.*)$/)[1]
+  @submodule_commit = type "git submodule status"
+  @submodule_commit.should match %r( [a-z0-9]{40} submodule)
+end
+
+Then /^the submodule should be updated$/ do
+  @submodule_commit[/[a-z0-9]{40}/].should_not == type("git submodule status")[/[a-z0-9]{40}/]
+end
+
+Then /^the submodule url should be changed$/ do
+  Dir.chdir "submodule" do
+    remote = type "git remote show origin"
+    remote.should_not match %r(Fetch URL: #{@submodule_url}$)
+    remote.should_not match %r(Push  URL: #{@submodule_url}$)
+  end
+end
+
+Then /^the submodule should be deleted$/ do
+  Then 'the directory should not be dirty'
+  @submodule_commit = type "git submodule status"
+  @submodule_commit.should_not match /.[a-z0-9]{40} submodule/
+
+end
+
+Then /^the submodule working directory should be clean$/ do
+  Dir.chdir "submodule" do
+    type("git status").should include "working directory clean"
+  end
+end

data/features/support/env.rb

@@ -1,22 +1,47 @@
-require "simplecov"
-SimpleCov.start do
-  command_name "Cucumber"
-  track_files "lib/**/*.rb"
-  add_filter "spec/"
-  add_filter "features/"
-end
-
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require "bard"
-require 'rspec/expectations'
-require 'fileutils'
+require 'ruby-debug'
+require 'grit'
+require 'spec/expectations'
+gem 'sqlite3-ruby'
 
-ENV["PATH"] = "#{File.dirname(File.expand_path(__FILE__))}:#{ENV['PATH']}"
+ENV["PATH"] += ":#{File.dirname(File.expand_path(__FILE__))}/../../bin"
 ENV["GIT_DIR"] = nil
 ENV["GIT_WORK_TREE"] = nil
 ENV["GIT_INDEX_FILE"] = nil
 
 ROOT = File.expand_path(File.dirname(__FILE__) + '/../..')
 
-# Ensure tmp directory exists
-FileUtils.mkdir_p(File.join(ROOT, "tmp"))
+# setup fixtures
+if File.exist?("/dev/shm")
+  FileUtils.rm_rf "tmp"
+  tmp_dir = "/dev/shm/bard_testing_tmp"
+  FileUtils.rm_rf tmp_dir
+  FileUtils.mkdir tmp_dir
+  `ln -s #{tmp_dir} tmp`
+else
+  FileUtils.rm_rf "tmp"
+  FileUtils.mkdir "tmp"
+end
+
+Dir.chdir 'tmp' do
+  `git clone --mirror --recursive #{ROOT}/fixtures/repo origin.git`
+
+  `git clone --bare --recursive origin.git submodule_a.git`
+  `git clone --bare --recursive origin.git submodule_b.git`
+  %w(development_a development_b staging production).each do |env|
+    `git clone --recursive origin.git #{env}`
+    Dir.chdir env do
+      FileUtils.cp "config/database.sample.yml", "config/database.yml"
+      `grb track master`
+      `git checkout master`
+      unless env == "production"
+        `grb track integration`
+        `git checkout integration`
+      end
+    end
+  end
+  FileUtils.mkdir "fixtures"
+  Dir.foreach "." do |file|
+    FileUtils.mv(file, "fixtures/") unless %w(fixtures . ..).include? file
+  end
+end

data/features/support/grit_ext.rb

@@ -0,0 +1,13 @@
+Grit::Repo.class_eval do
+  def remote_branches(remote = "origin")
+    branches = self.remotes
+    branches.reject!  { |r| r.name !~ %r(^#{remote}/) }
+    branches.collect! { |r| r.name.split('/')[1] }
+    branches.reject!  { |b| b == "HEAD" }
+  end
+
+  def find_common_ancestor(head1, head2)
+    `git merge-base #{head1} #{head2}`.chomp
+  end
+end
+

data/features/support/io.rb

@@ -0,0 +1,32 @@
+require "open3"
+def type(command)
+  @stdout, @stderr, @status = Open3.capture3(@env, command)
+  if ENV['DEBUG']
+    puts '-' * 20
+    puts "Executing command: #{command}"
+    puts "  Status: #{@status}"
+    puts "  Stdout:\n #{@stdout}"
+    puts "  Stderr:\n #{@stderr}"
+    puts '-' * 20
+  end
+  @stdout || @stderr
+end
+
+def file_append(file_name, contents)
+  File.open(file_name, 'ab') { |file| file.puts("\n#{contents}") }
+end
+
+def file_inject(file_name, sentinel, string, before_after=:after)
+  gsub_file file_name, /(#{Regexp.escape(sentinel)})/mi do |match|
+    if before_after == :after
+      "#{match}\n#{string}"
+    else
+      "#{string}\n#{match}"
+    end
+  end
+end
+
+def gsub_file(file_name, regexp, *args, &block)
+  content = File.read(file_name).gsub(regexp, *args, &block)
+  File.open(file_name, 'wb') { |file| file.write(content) }
+end

data/features/support/podman.rb

@@ -0,0 +1,153 @@
+require "fileutils"
+require "open3"
+require "securerandom"
+require "shellwords"
+require "testcontainers"
+
+module PodmanWorld
+  class << self
+    attr_accessor :podman_available, :podman_image_built
+  end
+
+  class PrerequisiteError < StandardError; end
+
+  def ensure_podman_available
+    return if @podman_available || PodmanWorld.podman_available
+
+    raise PrerequisiteError, "podman is not installed or not on PATH" unless system("command -v podman >/dev/null 2>&1")
+
+    configure_podman_socket
+    ensure_bard_test_image
+    FileUtils.chmod(0o600, podman_ssh_key_path)
+
+    PodmanWorld.podman_available = true
+    @podman_available = true
+  end
+
+  def configure_podman_socket
+    return if ENV["DOCKER_HOST"]
+
+    podman_socket = "/run/user/#{Process.uid}/podman/podman.sock"
+    unless File.exist?(podman_socket)
+      system("systemctl --user start podman.socket 2>/dev/null || podman system service --time=0 unix://#{podman_socket} &")
+      sleep 2
+    end
+
+    raise PrerequisiteError, "Podman socket not available at #{podman_socket}" unless File.exist?(podman_socket)
+
+    ENV["DOCKER_HOST"] = "unix://#{podman_socket}"
+  end
+
+  def ensure_bard_test_image
+    return if @podman_image_built || PodmanWorld.podman_image_built
+
+    raise PrerequisiteError, "Unable to pull ubuntu:22.04 image" unless system("podman pull ubuntu:22.04 >/dev/null 2>&1")
+
+    docker_dir = File.join(ROOT, "spec/acceptance/docker")
+    dockerfile = File.join(docker_dir, "Dockerfile")
+    unless system("podman build -t bard-test-server -f #{dockerfile} #{docker_dir} 2>&1")
+      raise PrerequisiteError, "Failed to build bard test image"
+    end
+
+    PodmanWorld.podman_image_built = true
+    @podman_image_built = true
+  end
+
+  def start_podman_container
+    ensure_podman_available
+
+    @podman_container = Testcontainers::DockerContainer
+      .new("localhost/bard-test-server:latest")
+      .with_exposed_port(22)
+      .with_name("bard-test-#{SecureRandom.hex(4)}")
+      .start
+
+    @podman_ssh_port = @podman_container.mapped_port(22)
+    wait_for_ssh
+    run_ssh("mkdir -p testproject")
+    write_bard_config
+  end
+
+  def wait_for_ssh
+    30.times do
+      return if run_ssh("echo ready", quiet: true)
+      sleep 0.5
+    end
+
+    raise PrerequisiteError, "SSH in podman container did not become ready"
+  end
+
+  def write_bard_config
+    FileUtils.mkdir_p(File.join(ROOT, "tmp"))
+    @bard_config_path = File.join(ROOT, "tmp", "test_bard_#{SecureRandom.hex(4)}.rb")
+
+    File.write(@bard_config_path, <<~RUBY)
+      server :production do
+        ssh "deploy@localhost:#{@podman_ssh_port}"
+        path "testproject"
+        ssh_key "#{podman_ssh_key_path}"
+        ping false
+      end
+    RUBY
+  end
+
+  def run_ssh(command, quiet: false)
+    escaped = Shellwords.escape(command)
+    ssh_command = [
+      "ssh",
+      "-o", "StrictHostKeyChecking=no",
+      "-o", "ConnectTimeout=1",
+      "-p", @podman_ssh_port.to_s,
+      "-i", podman_ssh_key_path,
+      "deploy@localhost",
+      "--",
+      "bash",
+      "-lc",
+      escaped
+    ].join(" ")
+
+    quiet ? system("#{ssh_command} >/dev/null 2>&1") : system(ssh_command)
+  end
+
+  def run_bard_against_container(command)
+    Dir.chdir(File.join(ROOT, "tmp")) do
+      FileUtils.cp(@bard_config_path, "bard.rb")
+      @stdout, @status = Open3.capture2e(@env || {}, "bard run #{command}")
+      @stderr = ""
+      FileUtils.rm_f("bard.rb")
+    end
+  end
+
+  def podman_ssh_key_path
+    @podman_ssh_key_path ||= File.expand_path(File.join(ROOT, "spec/acceptance/docker/test_key"))
+  end
+
+  def stop_podman_container
+    FileUtils.rm_f(@bard_config_path) if @bard_config_path
+    return unless @podman_container
+
+    @podman_container.stop
+    @podman_container.remove
+  rescue StandardError => e
+    warn "Failed to cleanup podman container: #{e.message}"
+  ensure
+    @podman_container = nil
+    @podman_ssh_port = nil
+  end
+end
+
+World(PodmanWorld)
+
+Before("@podman") do
+  @env ||= {}
+
+  begin
+    start_podman_container
+  rescue PodmanWorld::PrerequisiteError => e
+    pending(e.message)
+  end
+end
+
+After("@podman") do
+  stop_podman_container
+end

data/lib/bard/ci/github_actions.rb

@@ -5,8 +5,9 @@ require "bard/ci/runner"
 module Bard
   class CI
     class GithubActions < Runner
+
       def exists?
-        File.exist?(".github/workflows/ci.yml")
+        true
       end
 
       def console

data/lib/bard/ci/jenkins.rb

@@ -1,28 +1,12 @@
 require "json"
 require "bard/ci/runner"
-require "bard/secrets"
 
 module Bard
   class CI
     class Jenkins < Runner
-      def exists?
-        `curl -s -I #{ci_host}/` =~ /\b200 OK\b/ or create!
-      end
 
-      private def create!
-        git_url = `git remote get-url origin`.strip
-        config = JOB_CONFIG_XML.sub("GIT_URL", git_url)
-        if File.exist?("config/master.key")
-          master_key = File.read("config/master.key").strip
-          master_key_step = <<~XML.chomp
-            <hudson.tasks.Shell>
-                  <command>echo #{master_key} > config/master.key</command>
-                </hudson.tasks.Shell>
-
-          XML
-          config = config.sub("<builders>\n", "<builders>\n        #{master_key_step}")
-        end
-        `curl -s -X POST "http://#{auth}@ci.botandrose.com/createItem?name=#{project_name}" -H "Content-Type: application/xml" -d '#{config}'`
+      def exists?
+        `curl -s -I #{ci_host}/` =~ /\b200 OK\b/
       end
 
       def console
@@ -39,7 +23,7 @@ module Bard
       end
 
       def start
-        command = "curl -s -I -X POST -L '#{ci_host}/buildWithParameters?GIT_REF=#{branch}'"
+        command = "curl -s -I -X POST -L '#{ci_host}/buildWithParameters?GIT_REF=#{sha}'"
         output = `#{command}`
         @queueId = output[%r{Location: .+/queue/item/(\d+)/}, 1].to_i
       end
@@ -47,7 +31,7 @@ module Bard
       def building?
         retry_with_backoff do
           self.last_response = `curl -s #{ci_host}/#{job_id}/api/json?tree=building,result`
-          raise "Blank response from CI" if last_response.empty?
+          raise "Blank response from CI" if last_response.blank?
         end
         last_response.include? '"building":true'
       end
@@ -77,9 +61,9 @@ module Bard
       private
 
       def get_last_time_elapsed
-        response = retry_with_backoff do
+        retry_with_backoff do
           response = `curl -s #{ci_host}/lastStableBuild/api/xml`
-          raise "Blank response from CI" if response.empty?
+          raise "Blank response from CI" if response.blank?
           response
         end
         response.match(/<duration>(\d+)<\/duration>/)
@@ -90,7 +74,7 @@ module Bard
       end
 
       def auth
-        @auth ||= "#{Bard::Secrets.fetch("jenkins-user")}:#{Bard::Secrets.fetch("jenkins-token")}"
+        "botandrose:11cc2ba6ef2e43fbfbedc1f466724f6290"
       end
 
       def ci_host
@@ -101,10 +85,8 @@ module Bard
         retry_with_backoff do
           command = "curl -s -g '#{ci_host}/api/json?depth=1&tree=builds[queueId,number]'"
           output = `#{command}`
-          raise "Blank response from CI" if output.empty?
-          builds = JSON.parse(output)["builds"]
-          raise "Build not found in builds list" if builds.empty?
-          builds.first["queueId"] == @queueId
+          raise "Blank response from CI" if output.blank?
+          JSON.parse(output)["builds"][0]["queueId"] == @queueId
         end
       end
 
@@ -112,64 +94,11 @@ module Bard
         @job_id ||= begin
           retry_with_backoff do
             output = `curl -s -g '#{ci_host}/api/json?depth=1&tree=builds[queueId,number]'`
-            raise "Blank response from CI" if output.empty?
-            builds = JSON.parse(output)["builds"]
-            build = builds.find { |b| b["queueId"] == @queueId }
-            build["number"]
+            raise "Blank response from CI" if output.blank?
+            output[/"number":(\d+),"queueId":#{@queueId}\b/, 1].to_i
           end
         end
       end
-      JOB_CONFIG_XML = <<~XML
-        <?xml version="1.0" encoding="UTF-8"?>
-        <project>
-          <actions/>
-          <description></description>
-          <keepDependencies>false</keepDependencies>
-          <properties>
-            <hudson.model.ParametersDefinitionProperty>
-              <parameterDefinitions>
-                <hudson.model.StringParameterDefinition>
-                  <name>GIT_REF</name>
-                  <description></description>
-                  <defaultValue>master</defaultValue>
-                </hudson.model.StringParameterDefinition>
-              </parameterDefinitions>
-            </hudson.model.ParametersDefinitionProperty>
-          </properties>
-          <scm class="hudson.plugins.git.GitSCM" plugin="git@3.3.0">
-            <configVersion>2</configVersion>
-            <userRemoteConfigs>
-              <hudson.plugins.git.UserRemoteConfig>
-                <url>GIT_URL</url>
-              </hudson.plugins.git.UserRemoteConfig>
-            </userRemoteConfigs>
-            <branches>
-              <hudson.plugins.git.BranchSpec>
-                <name>$GIT_REF</name>
-              </hudson.plugins.git.BranchSpec>
-            </branches>
-            <doGenerateSubmoduleConfigurations>false</doGenerateSubmoduleConfigurations>
-            <submoduleCfg class="list"/>
-            <extensions/>
-          </scm>
-          <canRoam>true</canRoam>
-          <disabled>false</disabled>
-          <blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>
-          <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
-          <triggers/>
-          <concurrentBuild>false</concurrentBuild>
-          <builders>
-            <hudson.tasks.Shell>
-              <command>bash -l -c bin/setup</command>
-            </hudson.tasks.Shell>
-            <hudson.tasks.Shell>
-              <command>bash -l -c bin/ci</command>
-            </hudson.tasks.Shell>
-          </builders>
-          <publishers/>
-          <buildWrappers/>
-        </project>
-      XML
     end
   end
 end