bard 2.0.0.beta → 2.0.0

data/features/bard_push.feature

@@ -1,112 +0,0 @@
-Feature: bard push
-  Background:
-    Given a shared rails project
-
-  Scenario: Uploading local changes onto the remote integration branch
-    Given a commit
-    When I type "bard push"
-    And on staging, I type "bard stage"
-    Then the "integration" branch should match the "staging:integration" branch
-
-  Scenario: Uploading local changes onto a remote topic branch
-    Given a commit on the "topic" branch
-    And I am on the "topic" branch
-    When I type "bard push"
-    Then the "topic" branch should match the "origin/topic" branch
-
-  Scenario: Pushing a change that includes a migration
-    Given on staging, a staging database
-    And a commit with a new migration
-    When I type "bard push"
-    And on staging, I type "bard stage"
-    Then on staging, the staging database should include that migration
-
-  Scenario: Pushing a change that includes a gem dependency change
-    Given the test gem is not installed
-    And a commit that adds the test gem as a dependency
-    When I type "bard push"
-    And on staging, I type "bard stage"
-    Then on staging, the test gem should be installed
-
-  Scenario: Pushing a change should advance the staging HEAD and restart the staging rails server
-    Given a commit
-    When I type "bard push"
-    And on staging, I type "bard stage"
-    And the "integration" branch should match the "staging:integration" branch
-    Then on staging, passenger should have been restarted
-
-  Scenario: Pushing a change that includes a submodule addition
-    Given a commit with a new submodule
-    When I type "bard push"
-    And on staging, I type "bard stage"
-    Then on staging, there should be one new submodule
-    And the submodule branch should match the submodule origin branch
-    And on staging, the submodule working directory should be clean
-
-  Scenario: Pushing a change that includes a submodule update
-    Given a submodule
-    And a commit with a submodule update
-    When I type "bard push"
-    And on staging, I type "bard stage"
-    Then the submodule branch should match the submodule origin branch
-    Then on staging, the submodule working directory should be clean
-
-  Scenario: Pushing a change that includes a submodule url change
-    Given a submodule
-    And a commit with a submodule url change
-    When I type "bard push"
-    And on staging, I type "bard stage"
-    Then on staging, the submodule url should be changed
-    And the submodule branch should match the submodule origin branch
-    Then on staging, the submodule working directory should be clean
-
-  # TODO
-  #Scenario: Pushing a change that includes a submodule deletion
-  #  Given a submodule
-  #  Given I have committed a set of changes that includes a submodule deletion
-  #  When I type "bard push"
-  #  And on staging, I type "bard stage"
-  #  Then the remote submodule should be deleted
-
-  Scenario: Trying to bard push when not in the project root
-    Given I am in a subdirectory
-    When I type "bard push"
-    Then I should see the fatal error "root directory"
-
-  Scenario: Trying to bard push when not on the integration branch
-    Given a commit on the "master" branch
-    And I am on the "master" branch
-    When I type "bard push"
-    Then I should see the fatal error "on the master branch"
-    And the "master" branch should not match the "origin/master" branch
-
-  Scenario: Trying to bard push with a dirty working directory
-    Given a commit
-    And a dirty working directory
-    When I type "bard push"
-    Then I should see the fatal error "You have uncommitted changes!"
-    And the "integration" branch should not match the "origin/integration" branch
-
-  Scenario: Trying to bard push with a non-fast-foward changeset
-    Given a commit
-    And on development_b, a commit
-    And on development_b, I type "bard push"
-    When I type "bard push"
-    Then I should see the fatal error "Someone has pushed some changes"
-    And the "integration" branch should not match the "origin/integration" branch
-
-  Scenario: Trying to bard push with an uncommitted change to a submodule
-    Given a submodule
-    And a commit
-    And the submodule working directory is dirty
-    When I type "bard push"
-    Then I should see the fatal error "Micah"
-    And the "integration" branch should not match the "origin/integration" branch
-
-  Scenario: Trying to bard push with a committed but unpushed change to a submodule
-    Given a submodule
-    And a commit to the submodule
-    And a commit
-    When I type "bard push"
-    Then I should see the fatal error "Micah"
-    And the "integration" branch should not match the "origin/integration" branch

data/features/podman_testcontainers.feature

@@ -1,16 +0,0 @@
-@podman
-Feature: bard run against a podman TestContainers host
-  Background:
-    Given a podman testcontainer is ready for bard
-
-  Scenario: Running ls via bard run
-    Given a remote file "test-file.txt" exists in the test container
-    When I run bard "ls" against the test container
-    Then the bard command should succeed
-    And the bard output should include "test-file.txt"
-
-  Scenario: Running commands in isolated containers
-    Given a remote file "another-file.txt" containing "content" exists in the test container
-    When I run bard "cat another-file.txt" against the test container
-    Then the bard command should succeed
-    And the bard output should include "content"

data/features/step_definitions/check_steps.rb

@@ -1,47 +0,0 @@
-Then /^I should see the current version of bard$/ do
-  version = File.read("#{ROOT}/VERSION").chomp
-  @stdout.should =~ /bard\s+\(#{Regexp.escape(version)}\)/
-end
-
-Then /^I should see the current version of git$/ do
-  version = `git --version`[/[0-9]+\.[0-9]+\.[0-9]+/]
-  @stdout.should =~ /git\s+\(#{Regexp.escape(version)}/
-end
-
-Then /^I should see the current version of rubygems$/ do
-  version = `gem --version`.chomp
-  @stdout.should =~ /rubygems\s+\(#{Regexp.escape(version)}\)/
-end
-
-Then /^I should see the current version of ruby$/ do
-  version = `ruby --version`[/[0-9]+\.[0-9]+\.[0-9]+/]
-  @stdout.should =~ /ruby\s+\(#{Regexp.escape(version)}\)/
-end
-
-Given /^"([^\"]*)" is missing$/ do |file|
-  type "rm #{file}"
-end
-
-Given /^the database is missing$/ do
-  File.open "config/database.yml", "w" do |f|
-    f.puts <<-DB
-development:
-  adapter: mysql
-  username: root
-  password:
-  database: bad_bad_bad
-  socket: /var/run/mysqld/mysqld.sock
-DB
-  end
-end
-
-Given /^the submodule is missing$/ do
-  type "rm -rf submodule"
-  type "mkdir submodule"
-end
-
-Given /^the submodule has a detached head$/ do
-  Dir.chdir "submodule" do
-    type "git checkout `git rev-parse HEAD`"
-  end
-end

data/features/step_definitions/git_steps.rb

@@ -1,73 +0,0 @@
-Given /^I am on the "([^\"]+)" branch$/ do |branch|
-  if `git branch` =~ / #{branch}$/
-    type "git checkout #{branch}"
-  else
-    type "git checkout -b #{branch}"
-  end
-end
-
-Given /^there is no integration branch$/ do
-  type "git checkout master"
-  type "git branch -d integration"
-end
-
-Given /^the integration branch isnt tracking origin\/integration$/ do
-  type "git checkout master"
-  type "git branch -d integration"
-  type "git checkout -b integration"
-end
-
-Given /^a dirty working directory$/ do
-  File.open("dirty_file", "w") { |f| f.puts "dirty dirty" }
-end
-
-Given /^a commit$/ do
-  text = (rand * 100000000).round
-  type "echo '#{text}' > foobar_#{text}_file"
-  type "git add ."
-  type "git commit -am'test commit'"
-end
-
-Given /^a commit on the "([^\"]+)" branch$/ do |branch|
-  Given %(I am on the "#{branch}" branch)
-  text = (rand * 100000000).round
-  type "echo '#{text}' > #{branch}_#{text}_file"
-  type "git add ."
-  type "git commit -am 'testing #{branch} change'"
-  type "git checkout integration"
-end
-
-Then /^the directory should not be dirty$/ do
-  type("git status").should include "working directory clean"
-end
-
-Then /^I should be on the "([^\"]*)" branch$/ do |branch|
-  @repo.head.name.should == branch
-end
-
-Then /^there should not be a "([^\"]*)" branch$/ do |branch_name|
-  @repo.branches.any? { |branch| branch.name == branch_name }
-end
-
-Then /^the "([^\"]*)" branch (should|should not) match the "([^\"]*)" branch$/ do |local_branch, which, remote_branch|
-  type "git fetch origin"
-  local_env, local_branch = local_branch.split(':') if local_branch.include? ':'
-  local_env ||= "development_a"
-  remote_env, remote_branch = remote_branch.split(':') if remote_branch.include? ':'
-  remote_env ||= "development_a"
-  local_sha = @repos[local_env].commits(local_branch).first.id
-  remote_sha = @repos[remote_env].commits(remote_branch).first.id
-  which = which.gsub(/ /, '_').to_sym
-  local_sha.send(which) == remote_sha
-end
-
-Then /^the "([^\"]*)" branch should be a fast\-forward from the "([^\"]*)" branch$/ do |local_branch, remote_branch|
-  local_env, local_branch = local_branch.split(':') if local_branch.include? ':'
-  local_env ||= "development_a"
-  remote_env, remote_branch = remote_branch.split(':') if remote_branch.include? ':'
-  remote_env ||= "development_a"
-  local_sha = @repos[local_env].commits(local_branch).first.id
-  remote_sha = @repos[remote_env].commits(remote_branch).first.id
-  common_ancestor = @repos[local_env].find_common_ancestor local_sha, remote_sha
-  common_ancestor.should  == remote_sha
-end

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