static 1.0.0 → 1.0.1

data/vendor/vmc-0.5.0/spec/features/v2/push_flow_spec.rb

@@ -0,0 +1,125 @@
+require "spec_helper"
+require "webmock/rspec"
+
+if ENV['VMC_V2_TEST_USER'] && ENV['VMC_V2_TEST_PASSWORD'] && ENV['VMC_V2_TEST_TARGET']
+  describe 'A new user tries to use VMC against v2', :ruby19 => true do
+    include ConsoleAppSpeckerMatchers
+    include VMC::Interactive
+
+    let(:target) { ENV['VMC_V2_TEST_TARGET'] }
+    let(:username) { ENV['VMC_V2_TEST_USER'] }
+    let(:password) { ENV['VMC_V2_TEST_PASSWORD'] }
+
+    let(:app) do
+      fuzz = defined?(TRAVIS_BUILD_ID) ? TRAVIS_BUILD_ID : Time.new.to_f.to_s.gsub(".", "_")
+      "hello-sinatra-#{fuzz}"
+    end
+
+    before do
+      FileUtils.rm_rf File.expand_path(VMC::CONFIG_DIR)
+      WebMock.allow_net_connect!
+      Interact::Progress::Dots.start!
+    end
+
+    after do
+      vmc %W(delete #{app} -f --no-script)
+      Interact::Progress::Dots.stop!
+    end
+
+    it 'pushes a simple sinatra app using defaults as much as possible' do
+      run("#{vmc_bin} target http://#{target}") do |runner|
+        expect(runner).to say %r{Setting target to http://#{target}... OK}
+      end
+
+      run("#{vmc_bin} login") do |runner|
+        expect(runner).to say %r{target: https?://#{target}}
+
+        expect(runner).to say "Email>"
+        runner.send_keys username
+
+        expect(runner).to say "Password>"
+        runner.send_keys password
+
+        expect(runner).to say "Authenticating... OK"
+
+        expect(runner).to say(
+          "Organization>" => proc {
+            runner.send_keys "1"
+            expect(runner).to say /Switching to organization .*\.\.\. OK/
+          },
+          "Switching to organization" => proc {}
+        )
+
+        expect(runner).to say(
+          "Space>" => proc {
+            runner.send_keys "1"
+            expect(runner).to say /Switching to space .*\.\.\. OK/
+          },
+          "Switching to space" => proc {}
+        )
+      end
+
+      run("#{vmc_bin} app #{app}") do |runner|
+        expect(runner).to say "Unknown app '#{app}'."
+      end
+
+      Dir.chdir("#{SPEC_ROOT}/assets/hello-sinatra") do
+        run("#{vmc_bin} push") do |runner|
+          expect(runner).to say "Name>"
+          runner.send_keys app
+
+          expect(runner).to say "Instances> 1"
+          runner.send_keys ""
+
+          expect(runner).to say "Custom startup command> "
+          runner.send_keys "bundle exec ruby main.rb -p $PORT"
+
+          expect(runner).to say "Memory Limit>"
+          runner.send_keys "64M"
+
+          expect(runner).to say "Creating #{app}... OK"
+
+          expect(runner).to say "Subdomain> #{app}"
+          runner.send_keys ""
+
+          expect(runner).to say "1:"
+          expect(runner).to say "Domain>"
+          runner.send_keys "1"
+
+          expect(runner).to say(/Creating route #{app}\..*\.\.\. OK/)
+          expect(runner).to say(/Binding #{app}\..* to #{app}\.\.\. OK/)
+
+          expect(runner).to say "Create services for application?> n"
+          runner.send_keys ""
+
+          # skip this
+          if runner.expect "Bind other services to application?> n", 1
+            runner.send_keys ""
+          end
+
+          expect(runner).to say "Save configuration?> n"
+          runner.send_keys ""
+
+          expect(runner).to say "Uploading #{app}... OK"
+          expect(runner).to say "Starting #{app}... OK"
+
+          expect(runner).to say "Using Ruby", 10
+          expect(runner).to say "Your bundle is complete!", 30
+
+          expect(runner).to say "Checking #{app}..."
+          expect(runner).to say "1/1 instances"
+          expect(runner).to say "OK", 30
+        end
+      end
+
+      run("#{vmc_bin} delete #{app}") do |runner|
+        expect(runner).to say "Really delete #{app}?>"
+        runner.send_keys "y"
+
+        expect(runner).to say "Deleting #{app}... OK"
+      end
+    end
+  end
+else
+  $stderr.puts 'Skipping integration specs; please provide $VMC_TEST_TARGET, $VMC_TEST_USER, and $VMC_TEST_PASSWORD'
+end

data/vendor/vmc-0.5.0/spec/features/v2/switching_targets_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+if ENV['VMC_V2_TEST_TARGET']
+  describe 'A new user tries to use VMC against v2 production', :ruby19 => true do
+    include ConsoleAppSpeckerMatchers
+
+    let(:target) { ENV['VMC_V2_TEST_TARGET'] }
+
+    before do
+      Interact::Progress::Dots.start!
+    end
+
+    after do
+      Interact::Progress::Dots.stop!
+    end
+
+    it "can switch targets, even if a target is invalid" do
+      run("#{vmc_bin} target invalid-target") do |runner|
+        expect(runner).to say "target refused"
+        runner.wait_for_exit
+      end
+
+      run("#{vmc_bin} target #{target}") do |runner|
+        expect(runner).to say "Setting target"
+        expect(runner).to say target
+        runner.wait_for_exit
+      end
+    end
+  end
+else
+  $stderr.puts 'Skipping v2 integration specs; please provide $VMC_V2_TEST_TARGET'
+end

data/vendor/vmc-0.5.0/spec/spec_helper.rb

@@ -0,0 +1,63 @@
+SPEC_ROOT = File.dirname(__FILE__).freeze
+
+require "rspec"
+require "cfoundry"
+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
+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/
+    c.filter_run_excluding :ruby19 => true
+  end
+
+  c.include FakeHomeDir
+  c.include CommandHelper
+  c.include InteractHelper
+  c.include ConfigHelper
+
+  c.before(:all) do
+    WebMock.disable_net_connect!
+  end
+
+  c.before do
+    VMC::CLI.send(:class_variable_set, :@@client, nil)
+  end
+end
+
+def name_list(xs)
+  if xs.empty?
+    "none"
+  else
+    xs.collect(&:name).join(", ")
+  end
+end
+
+def run(command)
+  SpeckerRunner.new(command) do |runner|
+    yield runner
+  end
+end

data/vendor/vmc-0.5.0/spec/support/command_helper.rb

@@ -0,0 +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", "--no-script"]) }
+  end
+
+  def bool_flag(flag)
+    "#{'no-' unless send(flag)}#{flag.to_s.gsub('_', '-')}"
+  end
+
+  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/vendor/vmc-0.5.0/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/vendor/vmc-0.5.0/spec/support/console_app_specker_matchers.rb

@@ -0,0 +1,75 @@
+module ConsoleAppSpeckerMatchers
+  class InvalidInputError < StandardError; end
+
+  class ExpectOutputMatcher
+    attr_reader :timeout
+
+    def initialize(expected_output, timeout = 30)
+      @expected_output = expected_output
+      @timeout = timeout
+    end
+
+    def matches?(runner)
+      raise InvalidInputError unless runner.respond_to?(:expect)
+      expected = runner.expect(@expected_output, @timeout)
+      @full_output = runner.output
+      !!expected
+    end
+
+    def failure_message
+      "expected '#{@expected_output}' to be printed, but it wasn't. full output:\n#@full_output"
+    end
+
+    def negative_failure_message
+      "expected '#{@expected_output}' to not be printed, but it was. full output:\n#@full_output"
+    end
+  end
+
+
+  class ExitCodeMatcher
+    def initialize(expected_code)
+      @expected_code = expected_code
+    end
+
+    def matches?(runner)
+      raise InvalidInputError unless runner.respond_to?(:exit_code)
+
+      begin
+        Timeout.timeout(5) do
+          @actual_code = runner.exit_code
+        end
+
+        @actual_code == @expected_code
+      rescue Timeout::Error
+        @timed_out = true
+        false
+      end
+    end
+
+    def failure_message
+      if @timed_out
+        "expected process to exit with status #@expected_code, but it did not exit within 5 seconds"
+      else
+        "expected process to exit with status #{@expected_code}, but it exited with status #{@actual_code}"
+      end
+    end
+
+    def negative_failure_message
+      if @timed_out
+        "expected process to exit with status #@expected_code, but it did not exit within 5 seconds"
+      else
+        "expected process to not exit with status #{@expected_code}, but it did"
+      end
+    end
+  end
+
+  def say(expected_output, timeout = 30)
+    ExpectOutputMatcher.new(expected_output, timeout)
+  end
+
+  def have_exited_with(expected_code)
+    ExitCodeMatcher.new(expected_code)
+  end
+
+  alias :exit_with :have_exited_with
+end

data/vendor/vmc-0.5.0/spec/support/fake_home_dir.rb

@@ -0,0 +1,55 @@
+require "fakefs/safe"
+
+module FakeHomeDir
+  def self.included(klass)
+    super
+    klass.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def stub_home_dir_with(&block)
+      around do |example|
+        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
+
+  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 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/vendor/vmc-0.5.0/spec/support/interact_helper.rb

@@ -0,0 +1,29 @@
+module InteractHelper
+  def stub_ask(*args, &block)
+    a_stub = nil
+    any_instance_of VMC::CLI do |interactive|
+      a_stub = stub(interactive).ask(*args, &block)
+    end
+    a_stub
+  end
+
+  def mock_ask(*args, &block)
+    a_mock = nil
+    any_instance_of VMC::CLI do |interactive|
+      a_mock = mock(interactive).ask(*args, &block)
+    end
+    a_mock
+  end
+
+  def dont_allow_ask(*args)
+    any_instance_of VMC::CLI do |interactive|
+      dont_allow(interactive).ask(*args)
+    end
+  end
+
+  def mock_with_progress(message)
+    any_instance_of VMC::CLI do |interactive|
+      mock(interactive).with_progress(message) { |_, block| block.call }
+    end
+  end
+end

data/vendor/vmc-0.5.0/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/vendor/vmc-0.5.0/spec/support/shared_examples/input.rb

@@ -0,0 +1,14 @@
+shared_examples_for 'inputs must have descriptions' do
+  describe 'inputs' do
+    subject { command.inputs }
+
+    it "is not missing any descriptions" do
+      subject.each do |_, attrs|
+        next if attrs[:hidden]
+
+        expect(attrs[:description]).to be
+        expect(attrs[:description].strip).to_not be_empty
+      end
+    end
+  end
+end

data/vendor/vmc-0.5.0/spec/support/specker_runner.rb

@@ -0,0 +1,79 @@
+require "pty"
+
+class SpeckerRunner
+  def initialize(*args)
+    @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
+
+  def expect(matcher, timeout = 30)
+    case matcher
+    when Hash
+      expect_branches(matcher, timeout)
+    else
+      @expector.expect(matcher, timeout)
+    end
+  end
+
+  def send_keys(text_to_send)
+    @stdin.puts(text_to_send)
+  end
+
+  def exit_code
+    return @status if @status
+
+    status = nil
+    Timeout.timeout(5) do
+      _, status = Process.waitpid2(@pid)
+    end
+
+    @status = numeric_exit_code(status)
+  end
+
+  alias_method :wait_for_exit, :exit_code
+
+  def exited?
+    !running?
+  end
+
+  def running?
+    !!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 = @expector.expect(branch_names, timeout)
+    return unless expected
+
+    data = expected.first.match(/(#{branch_names})$/)
+    matched = data[1]
+    branches[matched].call
+  end
+
+  def numeric_exit_code(status)
+    status.exitstatus
+  rescue NoMethodError
+    status
+  end
+end

data/vendor/vmc-0.5.0/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/vendor/vmc-0.5.0/spec/vmc/cli/app/base_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require "vmc/cli/app/base"
+
+describe VMC::App::Base do
+  describe '#human_size' do
+    let(:base) { VMC::App::Base.new }
+
+    it { base.human_size(1_023).should == "1023.0B" }
+    it { base.human_size(1_024).should == "1.0K" }
+    it { base.human_size(1_024 * 1_024).should == "1.0M" }
+    it { base.human_size(1_024 * 1_024 * 1.5).should == "1.5M" }
+    it { base.human_size(1_024 * 1_024 * 1_024).should == "1.0G" }
+    it { base.human_size(1_024 * 1_024 * 1_024 * 1.5).should == "1.5G" }
+    it { base.human_size(1_024 * 1_024 * 1_024 * 1.234, 3).should == "1.234G" }
+    it { base.human_size(31395840).should == "29.9M" } # tests against floating point errors
+  end
+end