engineyard-serverside 2.8.0.pre4 → 3.0.4

data/spec/server_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-describe EY::Serverside::Server do
-  it "starts off empty" do
-    expect(EY::Serverside::Servers.new([], test_shell)).to be_empty
-  end
-
-  it "loads from hashes" do
-    servers = EY::Serverside::Servers.from_hashes([{:hostname => 'otherhost', :roles => %w[fire water]}], test_shell)
-    expect(servers.size).to eq(1)
-  end
-
-  it "rejects duplicates" do
-    expect do
-      EY::Serverside::Servers.from_hashes([
-        {:hostname => 'otherhost', :roles => [:fire]},
-        {:hostname => 'otherhost', :roles => [:water]},
-      ], test_shell)
-    end.to raise_error(EY::Serverside::Servers::DuplicateHostname)
-  end
-
-  it "makes sure your roles are symbols at creation time" do
-    servers = EY::Serverside::Servers.from_hashes([{:hostname => 'otherhost', :roles => %w[fire water]}], test_shell)
-    servers.each { |server| expect(server.roles).to eq(Set[:fire, :water]) }
-  end
-
-  context "filtering" do
-    before(:each) do
-      @servers = EY::Serverside::Servers.from_hashes([
-        {:hostname => 'localhost', :roles => [:ice, :cold]},
-        {:hostname => 'firewater', :roles => [:fire, :water]},
-        {:hostname => 'icewater',  :roles => [:ice, :water]},
-      ], test_shell)
-    end
-
-    it "#roles works with strings or symbols" do
-      expect(@servers.roles(:fire ).map{|s| s.hostname}).to eq(['firewater'])
-      expect(@servers.roles('fire').map{|s| s.hostname}).to eq(['firewater']) # hits the cache the second time
-    end
-
-    it "#roles finds all servers with the specified role" do
-      expect(@servers.roles(:ice).size).to eq(2)
-      expect(@servers.roles(:ice).map{|s| s.hostname}.sort).to eq(['icewater','localhost'])
-    end
-
-    it "#roles finds all servers with any of the specified roles" do
-      expect(@servers.roles(:ice, :water)).to eq(@servers)
-    end
-
-    it "#roles returns everything when asked for :all" do
-      expect(@servers.roles(:all)).to eq(@servers)
-    end
-
-    it "#roles also yields filtered server set" do
-      @servers.roles(:ice) do |servers|
-        expect(servers.size).to eq(2)
-        expect(servers.map{|s| s.hostname}.sort).to eq(['icewater','localhost'])
-      end
-    end
-
-    it "#localhost returns the localhost server" do
-      expect(@servers.localhost.hostname).to eq('localhost')
-    end
-
-    it "#remote returns non-localhost servers" do
-      expect(@servers.remote.size).to eq(2)
-      expect(@servers.remote.map {|s| s.hostname}.sort).to eq(['firewater','icewater'])
-    end
-  end
-end

data/spec/services_deploy_spec.rb

@@ -1,165 +0,0 @@
-require 'spec_helper'
-
-describe "Deploying an application with services" do
-  let(:shared_services_file) { deploy_dir.join('shared', 'config', 'ey_services_config_deploy.yml') }
-  let(:symlinked_services_file) { deploy_dir.join('current', 'config', 'ey_services_config_deploy.yml') }
-  let(:services_yml) { {"servicio" => {"foo" => "bar"}}.to_yaml }
-
-  describe "without ey_config" do
-    describe "with services and disabled ey_config warnings" do
-      before do
-        deploy_test_application('no_ey_config_no_warning', 'config' => {
-          'services_setup_command' => "echo '#{services_yml}' > #{shared_services_file}"
-        })
-      end
-
-      it "no warns about missing ey_config" do
-        expect(read_stderr).not_to include("WARNING: Gemfile.lock does not contain ey_config")
-      end
-    end
-
-    describe "with services" do
-      before do
-        deploy_test_application('no_ey_config', 'config' => {
-          'services_setup_command' => "echo '#{services_yml}' > #{shared_services_file}"
-        })
-      end
-
-      it "warns about missing ey_config" do
-        expect(read_stderr).to include("WARNING: Gemfile.lock does not contain ey_config")
-      end
-    end
-
-    describe "without services" do
-      before do
-        deploy_test_application('no_ey_config')
-      end
-
-      it "works without warnings" do
-        expect(read_output).not_to match(/WARNING/)
-      end
-    end
-  end
-
-  describe "deploy with invalid yaml ey_services_config_deploy" do
-    before do
-      @invalid_services_yml = "42"
-      deploy_test_application('default', 'config' => {
-        'services_setup_command' => "echo '#{@invalid_services_yml}' > #{shared_services_file}"
-      })
-    end
-
-    it "works without warning" do
-      expect(shared_services_file).to exist
-      expect(shared_services_file).not_to be_symlink
-      expect(shared_services_file.read).to eq("#{@invalid_services_yml}\n")
-
-      expect(symlinked_services_file).to exist
-      expect(symlinked_services_file).to be_symlink
-      expect(shared_services_file.read).to eq("#{@invalid_services_yml}\n")
-
-      expect(read_output).not_to match(/WARNING/)
-    end
-  end
-
-  describe "a succesful deploy" do
-    before do
-      deploy_test_application('default', 'config' => {
-        'services_setup_command' => "echo '#{services_yml}' > #{shared_services_file}"
-      })
-    end
-
-    it "creates and symlinks ey_services_config_deploy.yml" do
-      expect(shared_services_file).to exist
-      expect(shared_services_file).not_to be_symlink
-      expect(shared_services_file.read).to eq("#{services_yml}\n")
-
-      expect(symlinked_services_file).to exist
-      expect(symlinked_services_file).to be_symlink
-      expect(shared_services_file.read).to eq("#{services_yml}\n")
-
-      expect(read_output).not_to match(/WARNING/)
-    end
-  end
-
-  describe "a successful deploy followed by a deploy that can't find the command" do
-    before do
-      deploy_test_application('default', 'config' => {
-        'services_setup_command' => "echo '#{services_yml}' > #{shared_services_file}"
-      })
-      redeploy_test_application('config' => {
-        'services_check_command' => 'false'
-      })
-    end
-
-    it "silently fails" do
-      expect(shared_services_file).to exist
-      expect(shared_services_file).not_to be_symlink
-      expect(shared_services_file.read).to eq("#{services_yml}\n")
-
-      expect(symlinked_services_file).to exist
-      expect(symlinked_services_file).to be_symlink
-      expect(shared_services_file.read).to eq("#{services_yml}\n")
-
-      expect(read_output).not_to match(/WARNING/)
-    end
-
-  end
-
-  describe "a successful followed by a deploy that fails to fetch services" do
-    it "logs a warning and symlinks the existing config file when there is existing services file" do
-      deploy_test_application('default', 'config' => {
-        'services_setup_command' => "echo '#{services_yml}' > #{shared_services_file}"
-      })
-      redeploy_test_application('config' => {'services_setup_command' => 'false'})
-
-      expect(shared_services_file).to exist
-      expect(shared_services_file).not_to be_symlink
-      expect(shared_services_file.read).to eq("#{services_yml}\n")
-
-      expect(symlinked_services_file).to exist
-      expect(symlinked_services_file).to be_symlink
-      expect(shared_services_file.read).to eq("#{services_yml}\n")
-
-      expect(read_output).to include('WARNING: External services configuration not updated')
-    end
-
-    it "does not log a warning or symlink a config file when there is no existing services file" do
-      deploy_test_application('default', 'config' => {
-        'services_setup_command' => "echo '#{services_yml}' > #{shared_services_file}"
-      })
-      shared_services_file.delete
-      redeploy_test_application('config' => {'services_setup_command' => 'false'})
-
-      expect(shared_services_file).not_to exist
-      expect(symlinked_services_file).not_to exist
-
-      expect(read_output).not_to match(/WARNING/)
-    end
-  end
-
-  describe "a successful deploy followed by another successfull deploy" do
-    before do
-      deploy_test_application('default', 'config' => {
-        'services_setup_command' => "echo '#{services_yml}' > #{shared_services_file}"
-      })
-      @new_services_yml = {"servicio" => {"foo" => "bar2"}}.to_yaml
-      redeploy_test_application('config' => {
-        'services_setup_command' => "echo '#{@new_services_yml}' > #{shared_services_file}"
-      })
-    end
-
-    it "replaces the config with the new one (and symlinks)" do
-      expect(shared_services_file).to exist
-      expect(shared_services_file).not_to be_symlink
-      expect(shared_services_file.read).to eq("#{@new_services_yml}\n")
-
-      expect(symlinked_services_file).to exist
-      expect(symlinked_services_file).to be_symlink
-      expect(shared_services_file.read).to eq("#{@new_services_yml}\n")
-
-      expect(read_output).not_to match(/WARNING/)
-    end
-  end
-
-end

data/spec/shell_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-require 'tempfile'
-require 'timecop'
-
-describe EY::Serverside::Shell do
-  let(:output) { StringIO.new }
-
-  if "".respond_to?(:force_encoding)
-    it "status works for ut8" do
-      shell = EY::Serverside::Shell.new(:verbose => true, :stdout => output, :stderr => output, :log_path => tmpdir.join("engineyard-serverside-#{Time.now.to_i}-#{$$}.log"), :start_time => Time.local(2008, 9, 1, 12, 10, 25))
-      shell.status("\u2603".force_encoding("binary"))
-    end
-  end
-
-  it "has a timestamp before each line" do
-    time1 = Time.local(2008, 9, 1, 12, 0, 0)
-    time2 = Time.local(2008, 9, 1, 12, 3, 5)
-    time3 = Time.local(2008, 9, 1, 12, 10, 25)
-
-    @shell = EY::Serverside::Shell.new(:verbose => true, :stdout => output, :stderr => output, :log_path => tmpdir.join("engineyard-serverside-#{Time.now.to_i}-#{$$}.log"), :start_time => time1)
-
-    Timecop.freeze(time1) do
-      @shell.debug('debug')
-      @shell.notice('notice')
-    end
-    Timecop.freeze(time2) do
-      @shell.status('STATUS')
-      @shell.debug("multi\nline\ndebug")
-      @shell.warning("multi\nline\nwarning")
-    end
-    Timecop.freeze(time3) do
-      @shell.substatus("multi\nline\nsubstatus")
-    end
-
-    tstp_1 = "+    00s "
-    tstp_2 = "+ 3m 05s "
-    tstp_3 = "+10m 25s "
-    output.rewind
-    expect(output.read).to eq <<-OUTPUT
-#{tstp_1} debug
-
-\e[1m\e[33m#{tstp_1} !> notice
-\e[0m
-\e[1m\e[37m#{tstp_2} ~> STATUS
-\e[0m#{tstp_2} multi
-#{tstp_2} line
-#{tstp_2} debug
-
-\e[1m\e[33m#{tstp_2} !> WARNING: multi
-#{tstp_2} !> line
-#{tstp_2} !> warning
-\e[0m#{tstp_3}  ~ multi
-#{tstp_3}  ~ line
-#{tstp_3}  ~ substatus
-    OUTPUT
-  end
-end

data/spec/source/archive_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe EY::Serverside::Source::Archive do
-  before do
-    allow_any_instance_of(described_class).to receive(:runner) { RunnerDouble }
-  end
-
-  context "source" do
-    let(:shell) { ShellDouble.new }
-    subject {
-      described_class.new(shell,
-        :uri => "http://server.com/app.war",
-        :repository_cache => TMPDIR)
-    }
-
-    it "cleans cache" do
-      expect(subject).to respond_to(:gc_repository_cache)
-    end
-
-    it "compares revisions" do
-      expect(subject.same?("1", "1")).to be
-    end
-
-    it "understands short log message" do
-      expect(subject).to respond_to(:short_log_message)
-    end
-
-    it "updates the cache" do
-      subject.update_repository_cache
-    end
-
-  end
-end

data/spec/source/git_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe EY::Serverside::Source::Git do
-  before do
-    allow_any_instance_of(described_class).to receive(:runner) { RunnerDouble }
-  end
-
-  it "errors when required options are not used" do
-    expect { described_class.new(nil, {}) }.to raise_error(ArgumentError)
-  end
-
-  context "source" do
-    let(:shell) { ShellDouble.new }
-    subject {
-      described_class.new(shell,
-        :uri => "engineyard/engineyard-serverside.git",
-        :ref => "",
-        :repository_cache => "cache_dir")
-    }
-
-    it "creates the correct reivison file command" do
-      expect(subject.create_revision_file_command("directory/REVISION")).to eq(
-        "git --git-dir cache_dir/.git --work-tree cache_dir show --pretty=format:\"%H\" | head -1 > \"directory/REVISION\""
-      )
-    end
-
-    it "runs gc" do
-      expect(subject.gc_repository_cache.output).to eq("git --git-dir cache_dir/.git --work-tree cache_dir gc")
-      expect(shell.messages.last).to eq("Garbage collecting cached git repository to reduce disk usage.")
-    end
-
-    it "checks if it is the same revision" do
-      expect(subject.same?("", "")).to be
-    end
-
-    it "runs a short log message" do
-      expect(subject.short_log_message("rev")).to eq(
-        "git --git-dir cache_dir/.git --work-tree cache_dir log --pretty=oneline --abbrev-commit -n 1 'rev'"
-      )
-    end
-
-  end
-
-end

data/spec/sqlite3_deploy_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe "Deploying an application with sqlite3 as the only DB adapter in the Gemfile.lock" do
-  before(:all) do
-    @release_path  = nil
-    @shared_path   = nil
-    @framework_env = nil
-
-    deploy_test_application('sqlite3')
-    @shared_path   = @deployer.config.paths.shared
-    @release_path  = @deployer.config.paths.active_release
-    @framework_env = @deployer.config.framework_env
-  end
-
-  it 'should symlink database.sqlite3.yml' do
-    expect(@release_path.join('config', 'database.yml')).to exist
-  end
-
-  it 'should create database.sqlite3.yml in a shared location' do
-    expect(@shared_path.join('config', 'database.sqlite3.yml')).to exist
-  end
-
-  it 'should put a reference to a shared database in database.sqlite3.yml' do
-    contents = @release_path.join('config', 'database.yml').read
-    expect(contents).to include(@shared_path.join('databases', "#{@framework_env}.sqlite3").expand_path.to_s)
-  end
-
-  it 'should create the shared database' do
-    expect(@shared_path.join('databases', "#{@framework_env}.sqlite3")).to exist
-  end
-
-  it 'should contain valid yaml config' do
-    config = YAML.load_file(@release_path.join('config', 'database.yml'))
-    expect(config[@framework_env]['adapter']).to eq('sqlite3')
-    expect(config[@framework_env]['database']).to eq(@shared_path.join('databases', "#{@framework_env}.sqlite3").expand_path.to_s)
-  end
-
-end

data/spec/support/integration.rb

@@ -1,103 +0,0 @@
-class FullTestDeploy < EY::Serverside::Deploy
-  attr_reader :commands
-
-  class << self
-    attr_accessor :on_create_callback
-  end
-
-  def self.realnew(servers, config, shell)
-    on_create_callback.call(config) if on_create_callback # holy hax batman, this is insanity
-    super
-  end
-
-  def initialize(*)
-    super
-    @commands = []
-  end
-
-  # passwordless sudo is neither guaranteed nor desired
-  def sudo(cmd)
-    run(cmd)
-  end
-
-  def run(cmd)
-    @commands << cmd
-    super
-  end
-
-  def restart_command
-    Escape.shell_command(["echo", super]) + "> #{config.paths.active_release}/restart"
-  end
-
-  # we're probably running this spec under bundler, but a real
-  # deploy does not
-  def bundle
-    my_env = ENV.to_hash
-    super
-  ensure
-    ENV.replace(my_env)
-  end
-
-end
-
-class EY::Serverside::Deploy
-  class << self
-    alias_method :realnew, :new
-    attr_reader :config, :deployer
-  end
-  def self.new(servers, cfg, shell)
-    @config = cfg
-    @deployer = FullTestDeploy.realnew(servers, cfg, shell)
-  end
-end
-
-class EY::Serverside::Source::IntegrationSpec < EY::Serverside::Source
-  attr_reader :source_repo
-
-  def initialize(*a)
-    super
-    @source_repo = Pathname.new(uri) if uri # doesn't exist for rollback
-  end
-
-  def update_repository_cache
-    shell.status "Checking out #{@ref}"
-    install_git_base
-    copy_fixture_repo_files
-  end
-
-  def create_revision_file_command(revision_path)
-    "echo '#{@ref}' > #{revision_path}"
-  end
-
-  def short_log_message(revision)
-    "ref: #{revision} - Short log message"
-  end
-
-  def gc_repository_cache
-    shell.status "Garbage collecting cached git repository to reduce disk usage."
-  end
-
-  def same?(prev, active, path)
-    prev == active # for our tests, being the same commit is sufficient
-  end
-
-  private
-
-  def install_git_base
-    repository_cache.mkpath
-    git_base = FIXTURES_DIR.join('gitrepo.tar.gz')
-    shell.substatus "Test helpers copying base repo into #{repository_cache}"
-    shell.logged_system "tar xzf #{git_base} --strip-components 1 -C #{repository_cache}"
-  end
-
-  def copy_fixture_repo_files
-    if source_repo.exist?
-      shell.substatus "Test helpers copying repo fixture from #{source_repo}/ to #{repository_cache}"
-      # This uses a ruby method instead of shelling out because I was having
-      # trouble getting cp -R to behave consistently between distros.
-      system "rsync -aq #{source_repo}/ #{repository_cache}"
-    else
-      raise "Mock repo #{source_repo.inspect} does not exist. Path should be absolute. e.g. FIXTURES_DIR.join('repos','example')"
-    end
-  end
-end

data/spec/support/source_doubles.rb

@@ -1,28 +0,0 @@
-class ShellDouble
-  attr_reader :messages
-  def initialize
-    @messages = []
-  end
-
-  def status(message)
-    @messages << message
-  end
-end
-
-class RunnerDouble
-  def self.run(cmd, shell, server=nil)
-    new(cmd)
-  end
-
-  def initialize(cmd)
-    @cmd = cmd
-  end
-
-  def output
-    @cmd
-  end
-
-  def success?
-    true
-  end
-end

data/spec/support/timecop.rb

@@ -1,5 +0,0 @@
-require 'timecop'
-
-RSpec.configure do |config|
-  config.after(:each) { Timecop.return }
-end

data/spec/symlink_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe "Deploying an application with conflicting directories" do
-  before(:all) do
-    deploy_test_application('public_system')
-  end
-
-  it "does not remove the repository's public/system directory" do
-    expect(deploy_dir.join('current', 'public', 'system', 'cant_touch_this.txt')).to exist
-  end
-
-  it "warns that maintenance pages are broken" do
-    expect(read_output).to include("remove 'public/system' from your repository")
-  end
-end