vmc 0.5.0.beta.12 → 0.5.0.rc1

data/lib/vmc/cli/user/base.rb

@@ -19,7 +19,7 @@ module VMC
       end
 
       def validate_password_strength!(password)
-        strength = client.base.uaa.password_score(password)
+        strength = client.password_score(password)
         msg = "Your password strength is: #{strength}"
         fail msg if strength == :weak
         line msg

data/lib/vmc/test_support/command_helper.rb

@@ -1,28 +1,22 @@
 module VMC::TestSupport::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_success
-    print_debug_output if status != 0
-    expect(status).to eq 0
-  end
-
-  def expect_failure
-    print_debug_output if status == 0
-    expect(status).to eq 1
+  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])
   end
 
   def bool_flag(flag)
     "#{'no-' unless send(flag)}#{flag.to_s.gsub('_', '-')}"
   end
 
-  def print_debug_output
-    puts stdout.string.strip_progress_dots
-    puts stderr.string
-  end
-
   attr_reader :stdout, :stderr, :status
 
   def capture_output

data/lib/vmc/version.rb

@@ -1,3 +1,3 @@
 module VMC
-  VERSION = "0.5.0.beta.12".freeze
+  VERSION = "0.5.0.rc1".freeze
 end

data/spec/assets/specker_runner/specker_runner_input.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$stdout.sync = true
+print "started"
+typed = gets
+print "received #{typed}"

data/spec/assets/specker_runner/specker_runner_pause.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+print "started"
+sleep 0.5
+print " finished"

data/spec/console_app_specker/console_app_specker_matchers_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+include ConsoleAppSpeckerMatchers
+
+describe ConsoleAppSpeckerMatchers, :ruby19 => true do
+  describe "#say" do
+    it "returns an ExpectOutputMatcher" do
+      say("").should be_a(ExpectOutputMatcher)
+    end
+
+    context "with an explicit timeout" do
+      it "returns an ExpectOutputMatcher" do
+        matcher = say("", 30)
+        matcher.should be_a(ExpectOutputMatcher)
+        matcher.timeout.should == 30
+      end
+    end
+  end
+
+  describe "#have_exited_with" do
+    it "returns an ExitCodeMatcher" do
+      have_exited_with(1).should be_a(ExitCodeMatcher)
+    end
+
+    it "has synonyms" do
+      exit_with(1).should be_a(ExitCodeMatcher)
+    end
+  end
+end
+
+describe ExpectOutputMatcher, :ruby19 => true do
+  let(:expected_output) { "expected_output" }
+  let(:timeout) { 1 }
+
+  subject { ExpectOutputMatcher.new(expected_output, timeout) }
+
+  describe "#matches?" do
+    context "with something that isn't a runner" do
+      it "raises an exception" do
+        expect {
+          subject.matches?("c'est ne pas une specker runner")
+        }.to raise_exception(InvalidInputError)
+      end
+    end
+
+    context "with a valid runner" do
+      context "when the expected output is in the process output" do
+        it "finds the expected output" do
+          run("echo -n expected_output") do |runner|
+            subject.matches?(runner).should be_true
+          end
+        end
+      end
+
+      context "when the expected output is not in the process output" do
+        let(:runner) { SpeckerRunner.new('echo -n not_what_we_were_expecting') }
+
+        it "does not find the expected output" do
+          run("echo -n not_what_we_were_expecting") do |runner|
+            subject.matches?(runner).should be_false
+          end
+        end
+      end
+    end
+  end
+
+  context "failure messages" do
+    it "has a correct failure message" do
+      run("echo -n actual_output") do |runner|
+        subject.matches?(runner)
+        subject.failure_message.should == "expected 'expected_output' to be printed, but it wasn't. full output:\nactual_output"
+      end
+    end
+
+    it "has a correct negative failure message" do
+      run("echo -n actual_output") do |runner|
+        subject.matches?(runner)
+        subject.negative_failure_message.should == "expected 'expected_output' to not be printed, but it was. full output:\nactual_output"
+      end
+    end
+  end
+end
+
+describe ExitCodeMatcher, :ruby19 => true do
+  let(:expected_code) { 0 }
+
+  subject { ExitCodeMatcher.new(expected_code) }
+
+  describe "#matches?" do
+    context "with something that isn't a runner" do
+      it "raises an exception" do
+        expect {
+          subject.matches?("c'est ne pas une specker runner")
+        }.to raise_exception(InvalidInputError)
+      end
+    end
+
+    context "with a valid runner" do
+      context "and the command exited with the expected exit code" do
+        it "returns true" do
+          run("true") do |runner|
+            subject.matches?(runner).should be_true
+          end
+        end
+      end
+
+      context "and the command exits with a different exit code" do
+        it "returns false" do
+          run("false") do |runner|
+            subject.matches?(runner).should be_false
+          end
+        end
+      end
+
+      context "and the command runs for a while" do
+        it "waits for it to exit" do
+          run("sleep 0.5") do |runner|
+            subject.matches?(runner).should be_true
+          end
+        end
+      end
+    end
+  end
+
+  context "failure messages" do
+    context "with a command that's exited" do
+      it "has a correct failure message" do
+        run("false") do |runner|
+          subject.matches?(runner)
+          runner.wait_for_exit
+          subject.failure_message.should == "expected process to exit with status 0, but it exited with status 1"
+        end
+      end
+
+      it "has a correct negative failure message" do
+        run("false") do |runner|
+          subject.matches?(runner)
+          runner.wait_for_exit
+          subject.negative_failure_message.should == "expected process to not exit with status 0, but it did"
+        end
+      end
+    end
+
+    context "with a command that's still running" do
+      it "waits for it to exit" do
+        run("ruby -e 'sleep 1; exit 1'") do |runner|
+          subject.matches?(runner)
+          subject.failure_message.should == "expected process to exit with status 0, but it exited with status 1"
+        end
+      end
+    end
+  end
+end

data/spec/console_app_specker/specker_runner_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe SpeckerRunner, :ruby19 => true do
+  def asset(file)
+    File.expand_path("../../assets/specker_runner/#{file}", __FILE__)
+  end
+
+  let(:timeout) { 1 }
+
+  describe "running a command" do
+    let(:file) do
+      file = Tempfile.new('test-specker-runner')
+      sleep 1  # wait one second to make sure touching the file does something measurable
+      file
+    end
+
+    after { file.unlink }
+
+    it "runs a command" do
+      run("touch -a #{file.path}") do |runner|
+        runner.wait_for_exit
+        file.stat.atime.should > file.stat.mtime
+      end
+    end
+  end
+
+  describe "#expect" do
+    context "when the expected output shows up" do
+      it "returns a truthy value" do
+        run("echo -n foo") do |runner|
+          expect(runner.expect('foo')).to be_true
+        end
+      end
+    end
+
+    context "when the expected output never shows up" do
+      it "returns nil" do
+        run("echo the spanish inquisition") do |runner|
+          expect(runner.expect("something else", 0.5)).to be_nil
+        end
+      end
+    end
+
+    context "when the output eventually shows up" do
+      it "returns a truthy value" do
+        run("ruby #{asset("specker_runner_pause.rb")}") do |runner|
+          expect(runner.expect("finished")).to be_true
+        end
+      end
+    end
+
+    context "backspace" do
+      it "respects the backspace character" do
+        run("ruby -e 'puts \"foo a\\bbar\"'") do |runner|
+          expect(runner.expect("foo bar")).to be_true
+        end
+      end
+
+      it "does not go beyond the beginning of the line" do
+        run("ruby -e 'print \"foo abc\nx\\b\\bd\"'") do |runner|
+          expect(runner.expect("foo abc\nd")).to be_true
+        end
+      end
+
+      it "does not go beyond the beginning of the string" do
+        run("ruby -e 'print \"f\\b\\bbar\"'") do |runner|
+          expect(runner.expect("bar")).to be_true
+        end
+      end
+
+      it "leaves backspaced characters in the buffer until they're overwritten" do
+        run("ruby -e 'print \"foo abc\\b\\bd\"'") do |runner|
+          expect(runner.expect("foo adc")).to be_true
+        end
+      end
+    end
+
+    context "ansi escape sequences" do
+      it "filters ansi color sequences" do
+        run("ruby -e 'puts \"\\e[36mblue\\e[0m thing\"'") do |runner|
+          expect(runner.expect("blue thing")).to be_true
+        end
+      end
+    end
+
+    context "expecting multiple branches" do
+      context "and one of them matches" do
+        it "can be passed a hash of values with callbacks" do
+          run("echo 1 3") do |runner|
+            branches = {
+              "1" => proc { 1 },
+              "2" => proc { 2 },
+              "3" => proc { 3 }
+            }
+
+            expect(runner.expect(branches)).to eq 1
+            expect(runner.expect(branches)).to eq 3
+          end
+        end
+      end
+
+      context "and none of them match" do
+        it "returns nil when none of the branches match" do
+          run("echo not_a_number") do |runner|
+            expect(runner.expect({"1" => proc { 1 }}, timeout)).to be_nil
+          end
+        end
+      end
+    end
+  end
+
+  describe "#output" do
+    it "makes the entire command output (so far) available" do
+      run("echo 0 1 2 3") do |runner|
+        runner.expect("1")
+        runner.expect("3")
+        expect(runner.output).to eq "0 1 2 3"
+      end
+
+    end
+  end
+
+  describe "#send_keys" do
+    it "sends input and expects more output afterward" do
+      run("ruby #{asset("specker_runner_input.rb")}") do |runner|
+        expect(runner.expect("started")).to be_true
+        runner.send_keys("foo")
+        expect(runner.expect("foo")).to be_true
+      end
+    end
+  end
+
+  context "#exit_code" do
+    it "returns the exit code" do
+      run("ruby -e 'exit 42'") do |runner|
+        runner.wait_for_exit
+        expect(runner.exit_code).to eq(42)
+      end
+    end
+
+    context "when the command is still running" do
+      it "waits for the command to exit" do
+        run("sleep 0.5") do |runner|
+          expect(runner.exit_code).to eq(0)
+        end
+      end
+    end
+  end
+
+  context "#exited?" do
+    it "returns false if the command is still running" do
+      run("sleep 10") do |runner|
+        expect(runner.exited?).to eq false
+      end
+    end
+  end
+end

data/spec/features/new_user_flow_spec.rb

@@ -1,8 +1,13 @@
 require 'spec_helper'
 require "webmock/rspec"
 
+INTEGRATE_WITH = ENV["INTEGRATE_WITH"] || "default"
+
 if ENV['VMC_TEST_USER'] && ENV['VMC_TEST_PASSWORD'] && ENV['VMC_TEST_TARGET']
-  describe 'A new user tries to use VMC against v1 production' do
+  describe 'A new user tries to use VMC against v1 production', :ruby19 => true do
+    include ConsoleAppSpeckerMatchers
+    include VMC::Interactive
+
     let(:target) { ENV['VMC_TEST_TARGET'] }
     let(:username) { ENV['VMC_TEST_USER'] }
     let(:password) { ENV['VMC_TEST_PASSWORD'] }
@@ -15,61 +20,94 @@ if ENV['VMC_TEST_USER'] && ENV['VMC_TEST_PASSWORD'] && ENV['VMC_TEST_TARGET']
     end
 
     before do
-      FileUtils.rm_rf VMC::CONFIG_DIR
+      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
+
+    let(:vmc_bin) do
+      vmc = File.expand_path("#{SPEC_ROOT}/../bin/vmc.dev")
+      if INTEGRATE_WITH != 'default'
+        "rvm #{INTEGRATE_WITH}@vmc do #{vmc}"
+      else
+        vmc
+      end
     end
 
-    after { vmc %W(delete #{app} -f --no-script) }
+    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}}
 
-    it 'and pushes a simple sinatra app using defaults as much as possible' do
-      vmc %W[target #{target} --no-script]
-      expect_success
-      expect(stdout.string.strip_progress_dots).to eq <<-OUT.strip_heredoc
-        Setting target to https://#{target}... OK
-      OUT
+        expect(runner).to say "Email>"
+        runner.send_keys username
 
-      vmc %W[login #{username} --password #{password} --no-script]
-      expect_success
-      expect(stdout.string.strip_progress_dots).to eq <<-OUT.strip_heredoc
-        target: https://#{target}
+        expect(runner).to say "Password>"
+        runner.send_keys password
 
-        Authenticating... OK
-      OUT
+        expect(runner).to say "Authenticating... OK"
+      end
 
-      vmc %W[app #{app} --no-script]
-      expect_failure
-      expect(stderr.string).to eq <<-OUT.strip_heredoc
-        Unknown app '#{app}'.
-      OUT
+      run("#{vmc_bin} app #{app}") do |runner|
+        expect(runner).to say "Unknown app '#{app}'."
+      end
 
       Dir.chdir("#{SPEC_ROOT}/assets/hello-sinatra") do
-        vmc %W[push #{app} --runtime ruby19 --url #{app}-vmc-test.cloudfoundry.com -f --no-script]
-        expect_success
-        expect(stdout.string.strip_progress_dots).to eq <<-OUT.strip_heredoc
-          Creating #{app}... OK
-
-          Updating #{app}... OK
-          Uploading #{app}... OK
-          Starting #{app}... OK
-          Checking #{app}... OK
-        OUT
-
-        vmc %W[push #{app} --no-script]
-        expect_success
-        expect(stdout.string.strip_progress_dots).to eq <<-OUT.strip_heredoc
-          Uploading #{app}... OK
-          Stopping #{app}... OK
-
-          Starting #{app}... OK
-          Checking #{app}... OK
-        OUT
+        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 "1: sinatra"
+          expect(runner).to say "2: other"
+          expect(runner).to say "Framework> sinatra"
+          runner.send_keys ""
+
+          expect(runner).to say "1: ruby"
+          expect(runner).to say "Runtime>"
+          runner.send_keys "ruby19"
+
+          expect(runner).to say "1:"
+          expect(runner).to say "Memory Limit>"
+          runner.send_keys "64M"
+
+          expect(runner).to say "Creating #{app}... OK"
+
+          expect(runner).to say "1: #{app}."
+          expect(runner).to say "2: none"
+          expect(runner).to say "Domain>"
+          runner.send_keys ""
+
+          expect(runner).to say "Updating #{app}... OK"
+
+          expect(runner).to say "Create services for application?> n"
+          runner.send_keys ""
+
+          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 "Checking #{app}... OK", 30
+        end
       end
 
-      vmc %W[delete #{app} -f --no-script]
-      expect_success
-      expect(stdout.string.strip_progress_dots).to eq <<-OUT.strip_heredoc
-        Deleting #{app}... OK
-      OUT
+      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