vmc 0.5.0.rc1 → 0.5.0.rc2

data/spec/spec_helper.rb

@@ -6,6 +6,18 @@ require "cfoundry/test_support"
 require "vmc"
 require "vmc/test_support"
 require "webmock"
+require "ostruct"
+
+INTEGRATE_WITH = ENV["INTEGRATE_WITH"] || "default"
+
+def vmc_bin
+  vmc = File.expand_path("#{SPEC_ROOT}/../bin/vmc.dev")
+  if INTEGRATE_WITH != 'default'
+    "rvm #{INTEGRATE_WITH}@vmc do #{vmc}"
+  else
+    vmc
+  end
+end
 
 Dir[File.expand_path('../support/**/*.rb', __FILE__)].each do |file|
   require file
@@ -20,9 +32,10 @@ RSpec.configure do |c|
     c.filter_run_excluding :ruby19 => true
   end
 
-  c.include VMC::TestSupport::FakeHomeDir
-  c.include VMC::TestSupport::CommandHelper
-  c.include VMC::TestSupport::InteractHelper
+  c.include FakeHomeDir
+  c.include CommandHelper
+  c.include InteractHelper
+  c.include ConfigHelper
 
   c.before(:all) do
     WebMock.disable_net_connect!

data/{lib/vmc/test_support → spec/support}/command_helper.rb

@@ -1,4 +1,4 @@
-module VMC::TestSupport::CommandHelper
+module CommandHelper
   def vmc(argv)
     Mothership.new.exit_status 0
     stub(VMC::CLI).exit { |code| code }
@@ -20,13 +20,13 @@ module VMC::TestSupport::CommandHelper
   attr_reader :stdout, :stderr, :status
 
   def capture_output
-    real_stdout = $stdout
-    real_stderr = $stderr
+    $real_stdout = $stdout
+    $real_stderr = $stderr
     $stdout = @stdout = StringIO.new
     $stderr = @stderr = StringIO.new
     @status = yield
   ensure
-    $stdout = real_stdout
-    $stderr = real_stderr
+    $stdout = $real_stdout
+    $stderr = $real_stderr
   end
 end

data/spec/support/config_helper.rb

@@ -0,0 +1,15 @@
+module ConfigHelper
+  def write_token_file(config={})
+    File.open(File.expand_path(tokens_file_path), 'w') do |f|
+      f.puts YAML.dump(
+        { "https://api.some-domain.com" =>
+          {
+            :version => 2,
+            :token => 'bearer token',
+            :refresh_token => nil
+          }.merge(config)
+        }
+      )
+    end
+  end
+end

data/spec/support/console_app_specker_matchers.rb

@@ -10,7 +10,7 @@ module ConsoleAppSpeckerMatchers
     end
 
     def matches?(runner)
-      raise InvalidInputError unless runner.is_a?(SpeckerRunner)
+      raise InvalidInputError unless runner.respond_to?(:expect)
       expected = runner.expect(@expected_output, @timeout)
       @full_output = runner.output
       !!expected
@@ -32,7 +32,7 @@ module ConsoleAppSpeckerMatchers
     end
 
     def matches?(runner)
-      raise InvalidInputError unless runner.is_a?(SpeckerRunner)
+      raise InvalidInputError unless runner.respond_to?(:exit_code)
 
       begin
         Timeout.timeout(5) do

data/spec/support/fake_home_dir.rb

@@ -0,0 +1,42 @@
+module FakeHomeDir
+  def self.included(klass)
+    super
+    klass.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def use_fake_home_dir(&block)
+      around do |example|
+        dir = instance_exec(&block)
+        with_fake_home_dir(dir) do
+          example.call
+        end
+      end
+    end
+
+    def stub_home_dir_with(folder_name)
+      around do |example|
+        tmp_root = Dir.tmpdir
+        FileUtils.cp_r(File.expand_path("#{SPEC_ROOT}/fixtures/fake_home_dirs/#{folder_name}"), tmp_root)
+        fake_home_dir = "#{tmp_root}/#{folder_name}"
+        begin
+          with_fake_home_dir(fake_home_dir) do
+            example.call
+          end
+        ensure
+          FileUtils.rm_rf fake_home_dir
+        end
+      end
+    end
+  end
+
+  def with_fake_home_dir(dir, &block)
+    original_home_dir = ENV['HOME']
+    ENV['HOME'] = dir
+    begin
+      block.call
+    ensure
+      ENV['HOME'] = original_home_dir
+    end
+  end
+end

data/{lib/vmc/test_support → spec/support}/interact_helper.rb

@@ -1,4 +1,4 @@
-module VMC::TestSupport::InteractHelper
+module InteractHelper
   def stub_ask(*args, &block)
     a_stub = nil
     any_instance_of VMC::CLI do |interactive|

data/spec/support/shared_examples/errors.rb

@@ -0,0 +1,40 @@
+shared_examples_for "an error that's obvious to the user" do |options|
+  message = options[:with_message]
+
+  it "prints the message" do
+    subject
+    expect(stderr.string).to include message
+  end
+
+  it "sets the exit code to 1" do
+    mock(context).exit_status(1)
+    subject
+  end
+
+  it "does not mention ~/.vmc/crash" do
+    subject
+    expect(stderr.string).to_not include VMC::CRASH_FILE
+  end
+end
+
+shared_examples_for "an error that gets passed through" do |options|
+  before do
+    described_class.class_eval do
+      alias_method :wrap_errors_original, :wrap_errors
+      def wrap_errors
+        yield
+      end
+    end
+  end
+
+  after do
+    described_class.class_eval do
+      remove_method :wrap_errors
+      alias_method :wrap_errors, :wrap_errors_original
+    end
+  end
+
+  it "reraises the error" do
+    expect { subject }.to raise_error(options[:with_exception], options[:with_message])
+  end
+end

data/spec/support/specker_runner.rb

@@ -1,18 +1,15 @@
-require "expect"
 require "pty"
 
 class SpeckerRunner
-  attr_reader :output
-
   def initialize(*args)
-    @output = ""
-
     @stdout, slave = PTY.open
     system("stty raw", :in => slave)
     read, @stdin = IO.pipe
 
     @pid = spawn(*(args.push(:in => read, :out => slave, :err => slave)))
 
+    @expector = TrackingExpector.new(@stdout, ENV["DEBUG_BACON"])
+
     yield self
   end
 
@@ -21,7 +18,7 @@ class SpeckerRunner
     when Hash
       expect_branches(matcher, timeout)
     else
-      tracking_expect(matcher, timeout)
+      @expector.expect(matcher, timeout)
     end
   end
 
@@ -50,11 +47,23 @@ class SpeckerRunner
     !!Process.getpgid(@pid)
   end
 
+  def output
+    @expector.output
+  end
+
+  def debug
+    @expector.debug
+  end
+
+  def debug=(x)
+    @expector.debug = x
+  end
+
   private
 
   def expect_branches(branches, timeout)
     branch_names = /#{branches.keys.collect { |k| Regexp.quote(k) }.join("|")}/
-    expected = @stdout.expect(branch_names, timeout)
+    expected = @expector.expect(branch_names, timeout)
     return unless expected
 
     data = expected.first.match(/(#{branch_names})$/)
@@ -67,57 +76,4 @@ class SpeckerRunner
   rescue NoMethodError
     status
   end
-
-  def tracking_expect(pattern, timeout)
-    buffer = ''
-
-    case pattern
-    when String
-      pattern = Regexp.new(Regexp.quote(pattern))
-    when Regexp
-    else
-      raise TypeError, "unsupported pattern class: #{pattern.class}"
-    end
-
-    result = nil
-    position = 0
-    @unused ||= ""
-
-    while true
-      if !@unused.empty?
-        c = @unused.slice!(0).chr
-      elsif !IO.select([@stdout], nil, nil, timeout) || @stdout.eof?
-        @unused = buffer
-        break
-      else
-        c = @stdout.getc.chr
-      end
-
-      # wear your flip flops
-      unless (c == "\e") .. (c == "m")
-        if c == "\b"
-          if position > 0 && buffer[position - 1] && buffer[position - 1].chr != "\n"
-            position -= 1
-          end
-        else
-          if buffer.size > position
-            buffer[position] = c
-          else
-            buffer << c
-          end
-
-          position += 1
-        end
-      end
-
-      if matches = pattern.match(buffer)
-        result = [buffer, *matches.to_a[1..-1]]
-        break
-      end
-    end
-
-    @output << buffer
-
-    result
-  end
-end
+end

data/spec/support/tracking_expector.rb

@@ -0,0 +1,71 @@
+class TrackingExpector
+  attr_reader :output
+
+  def initialize(out, debug = false)
+    @out = out
+    @debug = debug
+    @unused = ""
+    @output = ""
+  end
+
+  def expect(pattern, timeout = 5)
+    buffer = ''
+
+    case pattern
+    when String
+      pattern = Regexp.new(Regexp.quote(pattern))
+    when Regexp
+    else
+      raise TypeError, "unsupported pattern class: #{pattern.class}"
+    end
+
+    result = nil
+    position = 0
+    @unused ||= ""
+
+    while true
+      if !@unused.empty?
+        c = @unused.slice!(0).chr
+      elsif output_ended?(timeout)
+        @unused = buffer
+        break
+      else
+        c = @out.getc.chr
+      end
+
+      STDOUT.putc c if @debug
+
+      # wear your flip flops
+      unless (c == "\e") .. (c == "m")
+        if c == "\b"
+          if position > 0 && buffer[position - 1] && buffer[position - 1].chr != "\n"
+            position -= 1
+          end
+        else
+          if buffer.size > position
+            buffer[position] = c
+          else
+            buffer << c
+          end
+
+          position += 1
+        end
+      end
+
+      if matches = pattern.match(buffer)
+        result = [buffer, *matches.to_a[1..-1]]
+        break
+      end
+    end
+
+    @output << buffer
+
+    result
+  end
+
+  private
+
+  def output_ended?(timeout)
+    (@out.is_a?(IO) && !IO.select([@out], nil, nil, timeout)) || @out.eof?
+  end
+end

data/spec/vmc/cli/app/instances_spec.rb

@@ -3,18 +3,18 @@ require 'stringio'
 
 describe VMC::App::Stats do
   let(:global) { { :color => false } }
-  let(:inputs) { {:app => apps[0]} }
+  let(:inputs) { { :app => apps[0] } }
   let(:given) { {} }
   let(:client) { fake_client(:apps => apps) }
   let(:apps) { [fake(:app, :name => "basic_app")] }
-  let(:time) { Time.local(2012,11,1,2,30)}
+  let(:time) { Time.local(2012, 11, 1, 2, 30) }
 
   before do
     any_instance_of(VMC::CLI) do |cli|
       stub(cli).client { client }
       stub(cli).precondition { nil }
     end
-    stub(client).base.stub!.instances(anything) do
+    stub(client.base).instances(anything) do
       {
         "12" => {:state => "STOPPED", :since => time.to_i, :debug_ip => "foo", :debug_port => "bar", :console_ip => "baz", :console_port => "qux"},
         "1" => {:state => "STOPPED", :since => time.to_i, :debug_ip => "foo", :debug_port => "bar", :console_ip => "baz", :console_port => "qux"},

data/spec/vmc/cli/app/start_spec.rb

@@ -0,0 +1,201 @@
+require "spec_helper"
+require "webmock/rspec"
+
+describe VMC::App::Start do
+  include ConsoleAppSpeckerMatchers
+
+  let(:client) { fake_client :apps => [app] }
+  let(:app) { fake :app }
+
+  def output
+    stdout.rewind
+    TrackingExpector.new(stdout)
+  end
+
+  def error_output
+    stderr.rewind
+    TrackingExpector.new(stderr)
+  end
+
+  before do
+    any_instance_of described_class do |cli|
+      stub(cli).precondition
+      stub(cli).client { client }
+    end
+  end
+
+  before(:all) do
+    described_class.class_eval do
+      def wrap_errors
+        yield
+      end
+    end
+  end
+
+  after(:all) do
+    described_class.class_eval do
+      remove_method :wrap_errors
+    end
+  end
+
+  subject { vmc %W[start #{app.name} --no-quiet] }
+
+  context "with an app that's already started" do
+    let(:app) { fake :app, :state => "STARTED" }
+
+    it "skips starting the application" do
+      dont_allow(app).start!
+      subject
+    end
+
+    it "says the app is already started" do
+      subject
+      expect(error_output).to say("Application #{app.name} is already started.")
+    end
+  end
+
+  context "with an app that's NOT already started" do
+    def self.it_says_application_is_starting
+      it "says that it's starting the application" do
+        subject
+        expect(output).to say("Starting #{app.name}... OK")
+      end
+    end
+
+    def self.it_prints_log_progress
+      it "prints out the log progress" do
+        subject
+        expect(output).to say(log_text)
+      end
+    end
+
+    def self.it_does_not_print_log_progress
+      it "does not print the log progress" do
+        subject
+        expect(output).to_not say(log_text)
+      end
+    end
+
+    def self.it_waits_for_application_to_become_healthy
+      describe "waits for application to become healthy" do
+        let(:app) { fake :app, :total_instances => 2 }
+
+        def after_sleep
+          any_instance_of described_class do |cli|
+            stub(cli).sleep { yield }
+          end
+        end
+
+        before do
+          stub(app).instances do
+            [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "DOWN"),
+              CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")
+            ]
+          end
+
+          after_sleep do
+            stub(app).instances { final_instances }
+          end
+        end
+
+        context "when all instances become running" do
+          let(:final_instances) do
+            [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING"),
+              CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")
+            ]
+          end
+
+          it "says app is started" do
+            subject
+            expect(output).to say("Checking #{app.name}...")
+            expect(output).to say("1 running, 1 down")
+            expect(output).to say("2 running")
+          end
+        end
+
+        context "when any instance becomes flapping" do
+          let(:final_instances) do
+            [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "FLAPPING"),
+              CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "STARTING")
+            ]
+          end
+
+          it "says app failed to start" do
+            subject
+            expect(output).to say("Checking #{app.name}...")
+            expect(output).to say("1 running, 1 down")
+            expect(output).to say("1 starting, 1 flapping")
+            expect(error_output).to say("Application failed to start")
+          end
+        end
+      end
+    end
+
+    before do
+      stub(app).invalidate!
+      stub(app).instances do
+        [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING") ]
+      end
+
+      stub(app).start!(true) do |_, blk|
+        app.state = "STARTED"
+        blk.call(log_url)
+      end
+    end
+
+    context "when progress log url is provided" do
+      let(:log_url) { "http://example.com/my-app-log" }
+      let(:log_text) { "Staging complete!" }
+
+      context "and progress log url is not available immediately" do
+        before do
+          stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
+            :status => 404, :body => "")
+        end
+        
+        it_says_application_is_starting
+        it_does_not_print_log_progress
+        it_waits_for_application_to_become_healthy
+      end
+
+      context "and progress log url becomes unavailable after some time" do
+        before do 
+          stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
+            :status => 200, :body => log_text[0...5])
+          stub_request(:get, "#{log_url}&tail&tail_offset=5").to_return(
+            :status => 200, :body => log_text[5..-1])
+          stub_request(:get, "#{log_url}&tail&tail_offset=#{log_text.size}").to_return(
+            :status => 404, :body => "")
+        end
+
+        it_says_application_is_starting
+        it_prints_log_progress
+        it_waits_for_application_to_become_healthy
+      end
+
+      context "and a request times out" do
+        before do 
+          stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
+            :should_timeout => true)
+          stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
+            :status => 200, :body => log_text)
+          stub_request(:get, "#{log_url}&tail&tail_offset=#{log_text.size}").to_return(
+            :status => 404, :body => "")
+        end
+
+        it_says_application_is_starting
+        it_prints_log_progress
+        it_waits_for_application_to_become_healthy
+      end
+    end
+
+    context "when progress log url is not provided" do
+      let(:log_url) { nil }
+      let(:log_text) { "Staging complete!" }
+
+      it_says_application_is_starting
+      it_does_not_print_log_progress
+      it_waits_for_application_to_become_healthy
+    end
+  end
+end