engineyard-serverside 2.8.0.pre4 → 2.8.0

data/spec/result/success_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+require 'result/success'
+
+module Result
+  describe Success do
+    let(:dummy) {Object.new}
+    let(:wrapped) {3}
+    let(:result) {described_class.new(wrapped)}
+
+    before(:each) do
+      allow(dummy).to receive(:process)
+    end
+
+    it 'is a result' do
+      expect(result).to be_a(Result::Base)
+    end
+
+    describe '#success?' do
+      let(:success) {result.success?}
+
+      it 'is true' do
+        expect(success).to eql(true)
+      end
+    end
+
+    describe '#failure?' do
+      let(:failure) {result.failure?}
+
+      it 'is false' do
+        expect(failure).to eql(false)
+      end
+    end
+
+    describe '#value' do
+      let(:value) {result.value}
+
+      it 'is the wrapped value' do
+        expect(value).to eql(wrapped)
+      end
+    end
+
+    describe '#error' do
+      let(:error) {result.error}
+
+      it 'raises an exception' do
+        expect {error}.to raise_exception
+      end
+    end
+
+    describe '#and_then' do
+      it 'yields the wrapped value to the block' do
+        expect(dummy).to receive(:process).with(wrapped)
+
+        result.and_then {|v| dummy.process(v)}
+      end
+
+      it 'is the result of yielding the wrapped value to the block' do
+        actual = result.and_then {|v| v + 1}
+
+        expect(actual).to eql(wrapped + 1)
+      end
+    end
+
+    describe '#or_else' do
+      it 'does not call the block' do
+        expect(dummy).not_to receive(:process)
+
+        result.or_else {|v| dummy.process(v)}
+      end
+
+      it 'is the success itself' do
+        actual = result.or_else {|v| v}
+
+        expect(actual).to eql(result)
+      end
+    end
+
+    describe '#on_success' do
+      it 'yields the wrapped value to the block' do
+        expect(dummy).to receive(:process).with(wrapped)
+
+        result.on_success {|v| dummy.process(v)}
+      end
+
+      it 'is the success itself' do
+        actual = result.on_success {|v| v}
+
+        expect(actual).to eql(result)
+      end
+    end
+
+    describe '#on_failure' do
+      it 'does not call the block' do
+        expect(dummy).not_to receive(:process)
+
+        result.on_failure {|v| dummy.process(v)}
+      end
+
+      it 'is the success itself' do
+        actual = result.on_failure {|v| v}
+
+        expect(actual).to eql(result)
+      end
+    end
+
+
+  end
+end

data/spec/result_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+require 'result'
+
+describe Result do
+  let(:value) {3}
+
+  describe '.Success' do
+    let(:result) {described_class.Success(value)}
+
+    it 'is a success' do
+      expect(result).to be_a(described_class::Success)
+    end
+  end
+
+  describe '.Failure' do
+    let(:result) {described_class.Failure(value)}
+
+    it 'is a failure' do
+      expect(result).to be_a(described_class::Failure)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,361 +1,15 @@
-$LOAD_PATH.push File.expand_path("../lib", File.dirname(__FILE__))
-
-unless defined?(Bundler)
-  require 'rubygems'
-end
-
-
 unless RUBY_VERSION =~ /^1\.8\./
   require 'simplecov'
-  SimpleCov.coverage_dir 'coverage/outside'
+  SimpleCov.coverage_dir 'coverage/inside'
   SimpleCov.start do
     add_filter '/spec/'
     add_filter '/features/'
     add_filter '/mock/'
     add_filter '/lib/vendor/'
     add_group 'CLI Workflows', 'lib/engineyard-serverside/cli/workflows/'
-    add_group 'Callbacks', 'lib/engineyard-serverside/callbacks'
+    add_group 'Callbacks', 'lib/engineyard-serverside/callbacks/'
   end
 end
 
-require 'pp'
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'engineyard-serverside'
-require 'engineyard-serverside-adapter'
-require 'support/integration'
-require 'support/source_doubles'
-require 'support/timecop'
-
-FIXTURES_DIR = Pathname.new(__FILE__).dirname.join("fixtures")
-TMPDIR = Pathname.new(__FILE__).dirname.parent.join('tmp')
-GROUP = `id -gn`.strip
-INTERNAL_KEY = Pathname.new("~/.ssh/id_rsa").expand_path
-
-module EY
-  module Serverside
-    def self.dna_json=(j)
-      @dna_json = j
-      @node = nil
-    end
-  end
-end
-
-module SpecDependencyHelpers
-  $NPM_INSTALLED = system('which npm 2>&1')
-  unless $NPM_INSTALLED
-    $stderr.puts "npm not found; skipping Node.js specs."
-  end
-
-  def with_npm_mocked(&block)
-    context("mocked") { yield true }
-    context("unmocked") { yield false } if $NPM_INSTALLED
-  end
-
-  $COMPOSER_INSTALLED = system('command -v composer > /dev/null')
-  if $COMPOSER_INSTALLED
-    $stderr.puts "composer found; skipping tests that expect it to be missing."
-  else
-    $stderr.puts "composer not found; skipping tests that expect it to be available."
-  end
-
-  def with_composer_mocked(&block)
-    context("mocked") { yield true }
-    context("unmocked") { yield false } if $COMPOSER_INSTALLED
-  end
-end
-
-RSpec.configure do |config|
-  config.extend SpecDependencyHelpers
-
-  config.before(:all) do
-    make_tmpdir
-    EY::Serverside.dna_json = MultiJson.dump({})
-  end
-
-  config.after(:all) do
-    delete_tmpdir
-  end
-
-  class VerboseStringIO < StringIO
-    def <<(str)
-      if ENV['VERBOSE'] || ENV['DEBUG']
-        STDERR << str
-      end
-      super
-    end
-  end
-
-  def tmpdir
-    TMPDIR
-  end
-
-  def make_tmpdir
-    tmpdir.mkpath
-  end
-
-  def delete_tmpdir
-    tmpdir.exist? && tmpdir.rmtree
-  end
-
-  def stdout
-    @stdout ||= VerboseStringIO.new
-  end
-
-  def stderr
-    @stderr ||= VerboseStringIO.new
-  end
-
-  def read_stdout
-    stdout.rewind
-    stdout.read
-  end
-
-  def read_stderr
-    stderr.rewind
-    stderr.read
-  end
-
-  def read_output
-    read_stdout + "\n" + read_stderr
-  end
-
-  def capture
-    begin
-      $stdout = @stdout = VerboseStringIO.new
-      $stderr = @stderr = VerboseStringIO.new
-      yield
-    ensure
-      $stdout, $stderr = STDOUT, STDERR
-    end
-  end
-
-  def test_shell(verbose=true)
-    @test_shell ||= begin
-                      @log_path = tmpdir.join("serverside-deploy-#{Time.now.to_f}-#{$$}.log")
-                      EY::Serverside::Shell.new(:verbose => verbose, :log_path => @log_path, :stdout => stdout, :stderr => stderr)
-                    end
-  end
-
-  def exist
-    be_exist
-  end
-
-  def bindir
-    @bindir ||= begin
-                  dir = tmpdir.join("ey_test_cmds_#{Time.now.to_f}_#{$$}")
-                  dir.mkpath
-                  dir
-                end
-  end
-
-  def mock_command(cmd, contents, &block)
-    bindir.join(cmd).open('w') do |f|
-      f.write contents
-      f.chmod(0755)
-    end
-    with_mocked_commands(&block) if block_given?
-  end
-
-  def mock_bundler(failure = false, &block)
-    mock_command('bundle', <<-SCRIPT, &block)
-#!#{`which ruby`}
-puts "Bundling gems"
-$stdout.flush
-#{failure && '$stderr.puts "bundle install failure"; exit 1'}
-    SCRIPT
-  end
-
-  def mock_npm(&block)
-    mock_command('npm', <<-SCRIPT, &block)
-#!/bin/bash
-echo "Running npm with $@"
-    SCRIPT
-  end
-
-  def mock_composer(&block)
-    mock_command('composer', <<-SCRIPT, &block)
-#!/bin/bash
-echo "Running composer with $@"
-    SCRIPT
-  end
-
-  def mock_sudo(&block)
-    mock_command('sudo', <<-SCRIPT, &block)
-#!/bin/bash
-echo "$@"
-exec "$@"
-    SCRIPT
-  end
-
-  def with_mocked_commands(&block)
-    with_env('PATH' => "#{bindir}:#{ENV['PATH']}", &block)
-  end
-
-  def with_env(new_env_vars)
-    raise ArgumentError, "with_env takes a block" unless block_given?
-
-    old_env_vars = {}
-    new_env_vars.each do |k, v|
-      if ENV.has_key?(k)
-        old_env_vars[k] = ENV[k]
-      end
-      ENV[k] = v if v
-    end
-
-    yield
-  ensure
-    new_env_vars.keys.each do |k|
-      if old_env_vars.has_key?(k)
-        ENV[k] = old_env_vars[k]
-      else
-        ENV.delete(k)
-      end
-    end
-  end
-
-
-  def deploy_dir
-    @deploy_dir ||= tmpdir.join("serverside-deploy-#{Time.now.to_f}-#{$$}")
-  end
-
-  def whoami
-    ENV['USER']
-  end
-
-  # set up EY::Serverside::Server like we're on a solo
-  def test_servers
-    @test_servers ||= EY::Serverside::Servers.from_hashes([{:hostname => 'localhost', :roles => %w[solo], :user => whoami}], test_shell)
-  end
-
-  def default_configuration
-    {
-      "source_class"     => "IntegrationSpec",
-      "deploy_to"        => deploy_dir.to_s,
-      "group"            => GROUP,
-      "stack"            => 'nginx_passenger',
-      "migrate"          => "ruby -e 'puts ENV[\"PATH\"]' > #{deploy_dir}/path-when-migrating",
-      "app"              => 'rails31',
-      "environment_name" => 'env',
-      "account_name"     => 'acc',
-      "framework_env"    => 'staging',
-      "branch"           => 'somebranch',
-      "verbose"          => true,
-      "git"              => FIXTURES_DIR.join('repos', 'default'),
-    }
-  end
-
-  def test_adapter(repo_fixture_name = 'default', extra_config = {})
-    options = default_configuration.merge({ "git" => FIXTURES_DIR.join('repos', repo_fixture_name)}).merge(extra_config)
-
-    # pretend there is a shared bundled_gems directory
-    deploy_dir.join('shared', 'bundled_gems').mkpath
-    %w(RUBY_VERSION SYSTEM_VERSION).each do |name|
-      deploy_dir.join('shared', 'bundled_gems', name).open("w") { |f| f.write("old\n") }
-    end
-
-    EY::Serverside::Adapter.new do |args|
-      args.app                = options['app']
-      args.environment_name   = options['environment_name']
-      args.account_name       = options['account_name']
-      args.migrate            = options['migrate']
-      args.ref                = options['branch']
-      args.git                = options['git']
-      args.serverside_version = Gem::Version.create(EY::Serverside::VERSION.dup).release
-      args.config             = {
-        "services_check_command" => "which echo",
-        "services_setup_command" => "echo 'services setup command'",
-        "source_class"           => options["source_class"],
-        "deploy_to"              => options["deploy_to"],
-        "group"                  => options["group"],
-      }.merge(options['config'] || {})
-      args.framework_env      = options['framework_env']
-      args.stack              = options['stack']
-      args.verbose            = options['verbose']
-      args.clean              = options['clean']
-      args.instances          = test_servers.map {|s| {:hostname => s.hostname, :roles => s.roles.to_a, :name => s.name} }
-    end
-  end
-
-  # When a repo fixture name is specified, the files found in the specified
-  # spec/fixtures/repos dir are copied into the test github repository.
-  def deploy_test_application(repo_fixture_name = 'default', extra_config = {}, &block)
-    Timecop.travel(1)
-    @adapter = test_adapter(repo_fixture_name, extra_config)
-    @argv = @adapter.deploy.commands.last.to_argv[2..-1]
-
-    FullTestDeploy.on_create_callback = block
-
-    mock_bundler(extra_config['bundle_install_fails'])
-    with_mocked_commands do
-      capture do
-        EY::Serverside::CLI::App.start(@argv)
-      end
-    end
-  ensure
-    @deployer = EY::Serverside::Deploy.deployer
-    @config = EY::Serverside::Deploy.config
-  end
-
-  def redeploy_test_application(extra_config = {}, &block)
-    Timecop.travel(1)
-    raise "Please deploy_test_application first" unless @argv
-    bundle_install_fails = extra_config.delete('bundle_install_fails')
-
-    @action = @adapter.deploy do |args|
-      extra_config.each do |key,val|
-        case key
-        when 'branch' then args.ref    = val
-        when 'config' then args.config = args.config.merge(val || {})
-        else               args.send("#{key}=", val)
-        end
-      end
-    end
-
-    @argv = @action.commands.last.to_argv[2..-1]
-
-    FullTestDeploy.on_create_callback = block
-
-    mock_bundler(bundle_install_fails)
-
-    with_mocked_commands do
-      capture do
-        EY::Serverside::CLI::App.start(@argv)
-      end
-    end
-  ensure
-    @deployer = EY::Serverside::Deploy.deployer
-    @config = EY::Serverside::Deploy.config
-  end
-
-  def enable_maintenance(extra_adapter_config = {})
-    @adapter = test_adapter("default", extra_adapter_config)
-    @argv = @adapter.enable_maintenance.commands.last.to_argv[2..-1]
-
-    with_mocked_commands do
-      capture do
-        EY::Serverside::CLI::App.start(@argv)
-      end
-    end
-  end
-
-  def disable_maintenance(extra_adapter_config = {})
-    @adapter = test_adapter("default", extra_adapter_config)
-    @argv = @adapter.disable_maintenance.commands.last.to_argv[2..-1]
-
-    with_mocked_commands do
-      capture do
-        EY::Serverside::CLI::App.start(@argv)
-      end
-    end
-  end
-
-  def maintenance_status(extra_adapter_config = {})
-    @adapter = test_adapter("default", extra_adapter_config)
-    @argv = @adapter.maintenance_status.commands.last.to_argv[2..-1]
-
-    with_mocked_commands do
-      capture do
-        EY::Serverside::CLI::App.start(@argv)
-      end
-    end
-  end
-end