vmc 0.5.0.rc4 → 0.5.0

data/Rakefile

@@ -1,8 +1,9 @@
 require "rake"
 require "rspec/core/rake_task"
 
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-require "vmc/version"
+specfile, _ = Dir["*.gemspec"]
+SPEC = Gem::Specification.load(specfile)
+CURRENT_VERSION = SPEC.version.to_s.freeze
 
 RSpec::Core::RakeTask.new(:spec)
 task :default => :spec
@@ -20,20 +21,81 @@ namespace :deploy do
     last_staging_sha == last_release_sha
   end
 
+  def next_minor
+    Gem::Version.new(CURRENT_VERSION + ".0").bump.to_s
+  end
+
+  def next_rc
+    unless CURRENT_VERSION =~ /rc/
+      "#{next_minor}.rc1"
+    end
+  end
+
   task :staging, :version do |_, args|
-    sh "gem bump --push #{"--version #{args.version}" if args.version}" if last_staging_ref_was_released?
+    version = args.version || next_rc
+    sh "gem bump --push #{"--version #{version}" if version}" if last_staging_ref_was_released?
     sh "git tag -f latest-staging"
     sh "git push origin :latest-staging"
     sh "git push origin latest-staging"
   end
 
-  task :gem do
+  task :candidate do
     sh "git fetch"
-    sh "git checkout #{last_staging_sha}"
+    sh "git checkout latest-staging"
     sh "gem release"
-    sh "git tag -f v#{VMC::VERSION}"
+    sh "git tag -f v#{CURRENT_VERSION}"
     sh "git tag -f latest-release"
     sh "git push origin :latest-release"
     sh "git push origin latest-release"
   end
+
+  task :release do
+    version = CURRENT_VERSION.sub(/\.rc\d+/, "")
+
+    prereleases = SPEC.runtime_dependencies.select(&:prerelease?)
+    unless prereleases.empty?
+      puts "The following dependencies must be released:"
+      prereleases.each do |pre|
+        puts "- #{pre.name}"
+      end
+
+      puts ""
+
+      raise
+    end
+
+    # grab the last release candidate
+    sh "git checkout latest-release -b release-v#{version}"
+
+    # update the version
+    sh "gem bump --version #{version}"
+
+    # switch to master
+    sh "git checkout master"
+
+    # merge the new version number back into master
+    sh "git merge release-v#{version}"
+
+    # apply tags
+    sh "git tag -f v#{version}"
+    sh "git tag -f latest-release"
+    sh "git tag -f latest-stable"
+    sh "git push origin master"
+    sh "git push origin :latest-release 2> /dev/null || exit 0"
+    sh "git push origin :latest-stable 2> /dev/null || exit 0"
+    sh "git push origin latest-release"
+    sh "git push origin latest-stable"
+    sh "git push origin v#{version}"
+
+    # check out the release tag
+    sh "git checkout latest-stable"
+
+    # build the gem and push the gem to rubygems
+    sh "rm -f *.gem"
+    sh "gem build *.gemspec"
+    sh "gem push *.gem"
+    sh "rm -f *.gem"
+
+    puts "You are now on the latest-release tag. You'll have to switch back to your working branch."
+  end
 end

data/lib/vmc/cli/start/target.rb

@@ -22,7 +22,14 @@ module VMC::Start
       if input.has?(:url)
         target = sane_target_url(input[:url])
         with_progress("Setting target to #{c(target, :name)}") do
-          CFoundry::Client.new(target) # check that it's valid before setting
+          begin
+            CFoundry::Client.new(target) # check that it's valid before setting
+          rescue CFoundry::TargetRefused
+            fail "Target refused connection."
+          rescue CFoundry::InvalidTarget
+            fail "Invalid target URI."
+          end
+
           set_target(target)
         end
       end

data/lib/vmc/version.rb

@@ -1,3 +1,3 @@
 module VMC
-  VERSION = "0.5.0.rc4".freeze
+  VERSION = "0.5.0".freeze
 end

data/spec/features/v1/new_user_flow_spec.rb

@@ -4,12 +4,8 @@ require 'ffaker'
 
 if ENV['VMC_TEST_USER'] && ENV['VMC_TEST_PASSWORD'] && ENV['VMC_TEST_TARGET']
   describe 'A new user tries to use VMC against v1 production', :ruby19 => true do
-    include ConsoleAppSpeckerMatchers
     include VMC::Interactive
 
-    let(:output) { StringIO.new }
-    let(:out) { output.string.strip_progress_dots }
-
     let(:target) { ENV['VMC_TEST_TARGET'] }
     let(:username) { ENV['VMC_TEST_USER'] }
     let(:password) { ENV['VMC_TEST_PASSWORD'] }

data/spec/spec_helper.rb

@@ -26,6 +26,8 @@ end
 RSpec.configure do |c|
   c.include Fake::FakeMethods
   c.include V1Fake::FakeMethods
+  c.include ConsoleAppSpeckerMatchers
+
   c.mock_with :rr
 
   if RUBY_VERSION =~ /^1\.8\.\d/
@@ -46,18 +48,6 @@ RSpec.configure do |c|
   end
 end
 
-class String
-  def strip_heredoc
-    min = scan(/^[ \t]*(?=\S)/).min
-    indent = min ? min.size : 0
-    gsub(/^[ \t]{#{indent}}/, '')
-  end
-
-  def strip_progress_dots
-    gsub(/\.  \x08([\x08\. ]+)/, "... ")
-  end
-end
-
 def name_list(xs)
   if xs.empty?
     "none"
@@ -66,19 +56,6 @@ def name_list(xs)
   end
 end
 
-def invoke_cli(cli, *args)
-  stub.proxy(cli).invoke.with_any_args
-  stub(cli.class).new { cli }
-  cli.invoke(*args)
-end
-
-def stub_output(cli)
-  stub(cli).print
-  stub(cli).puts
-  stub(Interact::Progress::Dots).start!
-  stub(Interact::Progress::Dots).stop!
-end
-
 def run(command)
   SpeckerRunner.new(command) do |runner|
     yield runner

data/spec/support/command_helper.rb

@@ -1,32 +1,80 @@
+def command(klass, &specs)
+  describe klass do
+    let(:stub_precondition?) { true }
+    before do
+      any_instance_of klass do |cli|
+        stub(cli).precondition if stub_precondition?
+        stub(cli).client { client }
+      end
+    end
+
+    before(:all) do
+      klass.class_eval do
+        def wrap_errors
+          yield
+        rescue VMC::UserError => e
+          err e.message
+        end
+      end
+    end
+
+    after(:all) do
+      klass.class_eval do
+        remove_method :wrap_errors
+      end
+    end
+
+    class_eval(&specs)
+  end
+end
+
 module CommandHelper
   def vmc(argv)
     Mothership.new.exit_status 0
     stub(VMC::CLI).exit { |code| code }
-    capture_output { VMC::CLI.start(argv + ["--debug"]) }
-  end
-
-  def expect_status_and_output(status = 0, out = "", err = "")
-    expect([
-      status,
-      stdout.string.strip_progress_dots,
-      stderr.string.strip_progress_dots
-    ]).to eq([status, out, err])
+    capture_output { VMC::CLI.start(argv + ["--debug", "--no-script"]) }
   end
 
   def bool_flag(flag)
     "#{'no-' unless send(flag)}#{flag.to_s.gsub('_', '-')}"
   end
 
-  attr_reader :stdout, :stderr, :status
+  attr_reader :stdout, :stderr, :stdin, :status
 
   def capture_output
     $real_stdout = $stdout
     $real_stderr = $stderr
+    $real_stdin = $stdin
     $stdout = @stdout = StringIO.new
     $stderr = @stderr = StringIO.new
+    $stdin = @stdin = StringIO.new
     @status = yield
+    @stdout.rewind
+    @stderr.rewind
+    @status
   ensure
     $stdout = $real_stdout
     $stderr = $real_stderr
+    $stdin = $real_stdin
+  end
+
+  def output
+    @output ||= TrackingExpector.new(stdout)
+  end
+
+  def error_output
+    @error_output ||= TrackingExpector.new(stderr)
+  end
+
+  def mock_invoke(*args)
+    any_instance_of described_class do |cli|
+      mock(cli).invoke *args
+    end
+  end
+
+  def dont_allow_invoke(*args)
+    any_instance_of described_class do |cli|
+      dont_allow(cli).invoke *args
+    end
   end
 end

data/spec/support/fake_home_dir.rb

@@ -1,3 +1,5 @@
+require "fakefs/safe"
+
 module FakeHomeDir
   def self.included(klass)
     super
@@ -5,38 +7,49 @@ module FakeHomeDir
   end
 
   module ClassMethods
-    def use_fake_home_dir(&block)
+    def stub_home_dir_with(&block)
       around do |example|
-        dir = instance_exec(&block)
-        with_fake_home_dir(dir) do
+        bootstrap_dir = instance_exec(&block)
+
+        if bootstrap_dir
+          fixture = File.expand_path(bootstrap_dir)
+          files = build_file_buffer(fixture)
+        end
+
+        FakeFS do
+          home = File.expand_path("~")
+          write_file_buffer(files, home) if files
           example.call
         end
+
+        FakeFS::FileSystem.clear
       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
+  private
+
+  def build_file_buffer(path)
+    files = {}
+
+    Dir.glob("#{path}/**/*", File::FNM_DOTMATCH).each do |file|
+      next if file =~ /\.$/
+      next if File.directory?(file)
+
+      files[file.sub(path + "/", "")] = File.read(file)
     end
+
+    files
   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
+  def write_file_buffer(files, path)
+    files.each do |file, body|
+      full = "#{path}/#{file}"
+
+      FileUtils.mkdir_p(File.dirname(full))
+      File.open(full, "w") do |io|
+        io.write body
+      end
     end
   end
 end

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

@@ -50,16 +50,16 @@ describe VMC::App::Stats do
 
   it 'prints out the instances in the correct order' do
     subject
-    expect(stdout.string).to match /.*instance \#1.*instance \#2.*instance \#12.*/m
+    expect(output).to say("instance #1")
+    expect(output).to say("instance #2")
+    expect(output).to say("instance #12")
   end
 
   it 'prints out one of the instances correctly' do
     subject
-    expect(stdout.string).to include <<-OUT.strip_heredoc
-      instance #2: started
-        started: #{time.strftime("%F %r")}
-        debugger: port bar at foo
-        console: port qux at baz
-    OUT
+    expect(output).to say("instance #2: started")
+    expect(output).to say("  started: #{time.strftime("%F %r")}")
+    expect(output).to say("  debugger: port bar at foo")
+    expect(output).to say("  console: port qux at baz")
   end
 end

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

@@ -1,23 +1,14 @@
 require "spec_helper"
 require "webmock/rspec"
 
-describe VMC::App::Scale do
-  let(:global) { { :color => false } }
-  let(:given) { {} }
-  let(:client) { fake_client }
-  let!(:cli) { described_class.new }
-
-  before do
-    stub(cli).client { client }
-    stub_output(cli)
-  end
-
-  subject { invoke_cli(cli, :scale, inputs, given, global) }
+command VMC::App::Scale do
+  let(:client) { fake_client :apps => [app] }
 
   context "when the --disk flag is given" do
     let(:before_value) { 512 }
     let(:app) { fake :app, :disk_quota => before_value }
-    let(:inputs) { { :app => app, :disk => "1G" } }
+
+    subject { vmc %W[scale #{app.name} --disk 1G] }
 
     it "changes the application's disk quota" do
       mock(app).update!
@@ -28,18 +19,20 @@ describe VMC::App::Scale do
   context "when the --memory flag is given" do
     let(:before_value) { 512 }
     let(:app) { fake :app, :memory => before_value }
-    let(:inputs) { { :app => app, :memory => "1G" } }
+
+    subject { vmc %W[scale #{app.name} --memory 1G] }
 
     it "changes the application's memory" do
       mock(app).update!
       expect { subject }.to change(app, :memory).from(before_value).to(1024)
     end
 
+    # TODO: determine if the command should do this on v2
     context "if --restart is true" do
       it "restarts the application" do
         stub(app).update!
         stub(app).started? { true }
-        mock(cli).invoke :restart, :app => app
+        mock_invoke :restart, :app => app
         subject
       end
     end
@@ -49,7 +42,7 @@ describe VMC::App::Scale do
     let(:before_value) { 3 }
     let(:app) { fake :app, :total_instances => before_value }
 
-    let(:inputs) { { :app => app, :instances => 5 } }
+    subject { vmc %W[scale #{app.name} --instances 5] }
 
     it "changes the application's number of instances" do
       mock(app).update!
@@ -60,7 +53,8 @@ describe VMC::App::Scale do
   context "when the --plan flag is given" do
     context "when the plan name begins with a 'p'" do
       let(:app) { fake :app, :production => false }
-      let(:inputs) { { :app => app, :plan => "P100" } }
+
+      subject { vmc %W[scale #{app.name} --plan P100] }
 
       it "changes the application's 'production' flag to true" do
         mock(app).update!
@@ -70,7 +64,8 @@ describe VMC::App::Scale do
 
     context "when the plan name does not begin with a 'p'" do
       let(:app) { fake :app, :production => true }
-      let(:inputs) { { :app => app, :plan => "D100" } }
+
+      subject { vmc %W[scale #{app.name} --plan D100] }
 
       it "changes the application's 'production' flag to false" do
         mock(app).update!

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

@@ -1,44 +1,11 @@
 require "spec_helper"
 require "webmock/rspec"
 
-describe VMC::App::Start do
-  include ConsoleAppSpeckerMatchers
-
+command VMC::App::Start do
   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] }
+  subject { vmc %W[start #{app.name}] }
 
   context "with an app that's already started" do
     let(:app) { fake :app, :state => "STARTED" }
@@ -152,14 +119,14 @@ describe VMC::App::Start 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 
+        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(
@@ -174,7 +141,7 @@ describe VMC::App::Start do
       end
 
       context "and a request times out" do
-        before 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(
@@ -198,4 +165,4 @@ describe VMC::App::Start do
       it_waits_for_application_to_become_healthy
     end
   end
-end
+end

data/spec/vmc/cli/domain/map_spec.rb

@@ -1,24 +1,22 @@
 require 'spec_helper'
 
-describe VMC::Domain::Map do
-  let(:global) { { :color => false } }
-  let(:given) { {} }
-  let(:client) { fake_client :current_organization => organization, :current_space => space }
-  let!(:cli) { described_class.new }
-
-  before do
-    stub(cli).client { client }
-    stub_output(cli)
+command VMC::Domain::Map do
+  let(:client) do
+    fake_client(
+      :current_organization => organization,
+      :current_space => space,
+      :spaces => [space],
+      :organizations => [organization],
+      :domains => domains)
   end
 
   let(:organization) { fake(:organization) }
-  let(:space) { fake(:space) }
+  let(:space) { fake(:space, :organization => organization) }
   let(:domain) { fake(:domain, :name => domain_name) }
   let(:domain_name) { "some.domain.com" }
+  let(:domains) { [domain] }
 
-  subject { invoke_cli(cli, :map_domain, inputs, given, global) }
-
-  shared_examples "binding a domain to a space" do
+  shared_examples_for "binding a domain to a space" do
     it "adds the domain to the space's organization" do
       mock(space.organization).add_domain(domain)
       stub(space).add_domain(domain)
@@ -32,7 +30,7 @@ describe VMC::Domain::Map do
     end
   end
 
-  shared_examples "binding a domain to an organization" do
+  shared_examples_for "binding a domain to an organization" do
     it 'does NOT add the domain to a space' do
       any_instance_of(space.class) do |space|
         dont_allow(space).add_domain(domain)
@@ -45,8 +43,10 @@ describe VMC::Domain::Map do
     end
   end
 
-  shared_examples "mapping a domain to a space" do
+  shared_examples_for "mapping a domain to a space" do
     context "when the domain does NOT exist" do
+      let(:domains) { [] }
+
       before do
         stub(client).domain { domain }
         stub(domain).create!
@@ -65,26 +65,22 @@ describe VMC::Domain::Map do
     end
 
     context "when the domain already exists" do
-      let(:client) {
-        fake_client :domains => [domain],
-                    :current_organization => organization,
-                    :current_space => space
-      }
-
       include_examples "binding a domain to a space"
     end
   end
 
   context 'when a domain and a space are passed' do
-    let(:inputs) { { :space => space, :name => domain_name } }
+    subject { vmc %W[map-domain #{domain.name} --space #{space.name}] }
 
     include_examples "mapping a domain to a space"
   end
 
   context 'when a domain and an organization are passed' do
-    let(:inputs) { { :organization => organization, :name => domain_name } }
+    subject { vmc %W[map-domain #{domain.name} --organization #{organization.name}] }
 
     context "and the domain does NOT exist" do
+      let(:domains) { [] }
+
       before do
         stub(client).domain { domain }
         stub(domain).create!
@@ -93,18 +89,18 @@ describe VMC::Domain::Map do
 
       include_examples "binding a domain to an organization"
 
-      it 'adds the domain to the organization' do
-        mock(organization).add_domain(domain)
+      it 'creates the domain' do
+        mock(domain).create!
         subject
+        expect(domain.name).to eq domain_name
       end
 
       context "and the --shared option is passed" do
-        let(:inputs) { { :organization => organization, :name => domain_name, :shared => true } }
+        subject { vmc %W[map-domain #{domain.name} --organization #{organization.name} --shared] }
 
         it 'adds the domain to the organization' do
-          mock(domain).create!
+          mock(organization).add_domain(domain)
           subject
-          expect(domain.name).to eq domain_name
         end
 
         it "does not add the domain to a specific organization" do
@@ -116,25 +112,19 @@ describe VMC::Domain::Map do
     end
 
     context "and the domain already exists" do
-      let(:client) {
-        fake_client :domains => [domain],
-                    :current_organization => organization,
-                    :current_space => space
-      }
-
       include_examples "binding a domain to an organization"
     end
   end
 
   context 'when a domain, organization, and space is passed' do
-    let(:inputs) { { :name => domain_name, :organization => organization, :space => space } }
+    subject { vmc %W[map-domain #{domain.name} --space #{space.name} --organization #{organization.name}] }
 
     include_examples "mapping a domain to a space"
   end
 
   context 'when only a domain is passed' do
-    let(:inputs) { { :name => domain_name } }
+    subject { vmc %W[map-domain #{domain.name}] }
 
     include_examples "mapping a domain to a space"
   end
-end
+end