bard 1.8.0.beta → 1.8.0.beta2

data/features/step_definitions/global_steps.rb

@@ -1,56 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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/grit_ext.rb

@@ -1,13 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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