cf 0.1.5 → 0.6.0.rc1

data/spec/cf/cli/space/switch_space_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require "cf/cli/space/switch"
+
+describe CF::Space::Switch do
+  let(:space_to_switch_to) { spaces.last }
+  let(:spaces) { fake_list(:space, 3) }
+  let(:organization) { fake(:organization, :spaces => spaces) }
+  let(:client) { fake_client(:current_organization => organization, :spaces => spaces) }
+
+  before do
+    any_instance_of described_class do |cli|
+      stub(cli).client { client }
+      stub(cli).precondition { nil }
+    end
+  end
+
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:switch_space] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Switch to a space" }
+      it { expect(Mothership::Help.group(:spaces)).to include(subject) }
+    end
+
+    include_examples 'inputs must have descriptions'
+
+    describe 'arguments' do
+      subject { command.arguments }
+      it 'has the correct argument order' do
+        should eq([{ :type => :normal, :value => nil, :name => :name }])
+      end
+    end
+  end
+
+  subject { cf %W[--no-quiet switch-space #{space_to_switch_to.name} --no-color] }
+
+  context "when the space exists" do
+    it "switches to that space" do
+      any_instance_of(Mothership) do |m|
+        mock(m).invoke(:target, {:space => space_to_switch_to})
+      end
+
+      subject
+    end
+  end
+
+  context "when the space does not exist" do
+    let(:space_to_switch_to) { fake(:space, :name => "unique-name") }
+
+    it_behaves_like "an error that gets passed through",
+      :with_exception => CF::UserError,
+      :with_message => "The space unique-name does not exist, please create the space first."
+  end
+end

data/spec/cf/cli/start/info_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe CF::Start::Info do
+  let(:frameworks) { false }
+  let(:runtimes) { false }
+  let(:services) { false }
+  let(:all) { false }
+
+  let(:client) do
+    fake_client :frameworks => fake_list(:framework, 3),
+      :runtimes => fake_list(:runtime, 3),
+      :services => fake_list(:service, 3),
+      :token => CFoundry::AuthToken.new("bearer some-access-token")
+  end
+
+  let(:target_info) do
+    { :description => "Some description",
+      :version => 2,
+      :support => "http://example.com"
+    }
+  end
+
+  before do
+    any_instance_of described_class do |cli|
+      stub(cli).client { client }
+    end
+  end
+
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:info] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Display information on the current target, user, etc." }
+      it { expect(Mothership::Help.group(:start)).to include(subject) }
+    end
+
+    include_examples 'inputs must have descriptions'
+
+    describe 'flags' do
+      subject { command.flags }
+
+      its(["-f"]) { should eq :frameworks }
+      its(["-r"]) { should eq :runtimes }
+      its(["-s"]) { should eq :services }
+      its(["-a"]) { should eq :all }
+    end
+
+    describe 'arguments' do
+      subject { command.arguments }
+      it { should be_empty }
+    end
+  end
+
+
+  subject { cf %W[info --#{bool_flag(:frameworks)} --#{bool_flag(:runtimes)} --#{bool_flag(:services)} --#{bool_flag(:all)} --no-force --no-quiet] }
+
+  context 'when given no flags' do
+    it "displays target information" do
+      mock(client).info { target_info }
+
+      subject
+
+      stdout.rewind
+      expect(stdout.readline).to eq "Some description\n"
+      expect(stdout.readline).to eq "\n"
+      expect(stdout.readline).to eq "target: #{client.target}\n"
+      expect(stdout.readline).to eq "  version: 2\n"
+      expect(stdout.readline).to eq "  support: http://example.com\n"
+    end
+  end
+
+  context 'when given --frameworks' do
+    let(:frameworks) { true }
+
+    it 'does not grab /info' do
+      dont_allow(client).info
+      subject
+    end
+
+    it 'lists frameworks on the target' do
+      subject
+
+      stdout.rewind
+      expect(stdout.readline).to match /Getting frameworks.*OK/
+      expect(stdout.readline).to eq "\n"
+      expect(stdout.readline).to match /framework\s+description/
+
+      client.frameworks.sort_by(&:name).each do |f|
+        expect(stdout.readline).to match /#{f.name}\s+#{f.description}/
+      end
+    end
+  end
+
+  context 'when given --runtimes' do
+    let(:runtimes) { true }
+
+    it 'does not grab /info' do
+      dont_allow(client).info
+      subject
+    end
+
+    it 'lists runtimes on the target' do
+      subject
+
+      stdout.rewind
+      expect(stdout.readline).to match /Getting runtimes.*OK/
+      expect(stdout.readline).to eq "\n"
+      expect(stdout.readline).to match /runtime\s+description/
+
+      client.runtimes.sort_by(&:name).each do |r|
+        expect(stdout.readline).to match /#{r.name}\s+#{r.description}/
+      end
+    end
+  end
+
+  context 'when given --services' do
+    let(:services) { true }
+
+    it 'does not grab /info' do
+      dont_allow(client).info
+      subject
+    end
+
+    it 'lists services on the target' do
+      subject
+
+      stdout.rewind
+      expect(stdout.readline).to match /Getting services.*OK/
+      expect(stdout.readline).to eq "\n"
+      expect(stdout.readline).to match /service\s+version\s+provider\s+plans\s+description/
+
+      client.services.sort_by(&:label).each do |s|
+        expect(stdout.readline).to match /#{s.label}\s+#{s.version}\s+#{s.provider}.+#{s.description}/
+      end
+    end
+  end
+
+  context 'when given --all' do
+    let(:all) { true }
+
+    it 'combines --frameworks --runtimes and --services' do
+      mock(client).info { target_info }
+
+      subject
+
+      stdout.rewind
+      expect(stdout.readline).to match /Getting runtimes.*OK/
+      expect(stdout.readline).to match /Getting frameworks.*OK/
+      expect(stdout.readline).to match /Getting services.*OK/
+    end
+  end
+
+  context 'when there is no target' do
+    let(:client) { nil }
+    it_behaves_like "an error that gets passed through",
+      :with_exception => CF::UserError,
+      :with_message => "Please select a target with 'cf target'."
+  end
+end

data/spec/cf/cli/start/login_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+command CF::Start::Login do
+  let(:client) { fake_client :organizations => [] }
+
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:login] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Authenticate with the target" }
+      specify { expect(Mothership::Help.group(:start)).to include(subject) }
+    end
+
+    include_examples 'inputs must have descriptions'
+
+    describe 'flags' do
+      subject { command.flags }
+
+      its(["-o"]) { should eq :organization }
+      its(["--org"]) { should eq :organization }
+      its(["--email"]) { should eq :username }
+      its(["-s"]) { should eq :space }
+    end
+
+    describe 'arguments' do
+      subject(:arguments) { command.arguments }
+      it 'have the correct commands' do
+        expect(arguments).to eq [{:type => :optional, :value => :email, :name => :username}]
+      end
+    end
+  end
+
+  describe "running the command" do
+    stub_home_dir_with { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
+
+    let(:auth_token) { CFoundry::AuthToken.new("bearer some-new-access-token", "some-new-refresh-token") }
+    let(:tokens_yaml) { YAML.load_file(File.expand_path(tokens_file_path)) }
+    let(:tokens_file_path) { '~/.cf/tokens.yml' }
+    let(:organizations) { [] }
+
+    before do
+      stub(client).login("my-username", "my-password") { auth_token }
+      stub(client).login_prompts do
+        {
+          :username => ["text", "Username"],
+          :password => ["password", "8-digit PIN"]
+        }
+      end
+    end
+
+    subject { cf ["login"] }
+
+    it "logs in with the provided credentials and saves the token data to the YAML file" do
+      stub_ask("Username", {}) { "my-username" }
+      stub_ask("8-digit PIN", {:echo => "*", :forget => true}) { "my-password" }
+
+      subject
+
+      expect(tokens_yaml["https://api.some-domain.com"][:token]).to eq("bearer some-new-access-token")
+      expect(tokens_yaml["https://api.some-domain.com"][:refresh_token]).to eq("some-new-refresh-token")
+    end
+
+    context "with space and org in the token file" do
+      before do
+        write_token_file(:space => "space-id-1", :organization => "organization-id-1")
+        stub_ask("Username", {}) { "my-username" }
+        stub_ask("8-digit PIN", {:echo => "*", :forget => true}) { "my-password" }
+      end
+
+      context "when the user has no organizations" do
+        it "clears the org and space param from the token file" do
+          subject
+
+          expect(tokens_yaml["https://api.some-domain.com"][:space]).to be_nil
+          expect(tokens_yaml["https://api.some-domain.com"][:organization]).to be_nil
+        end
+      end
+
+      context "when the user has an organization, but no spaces" do
+        let(:client) {
+          fake_client :organizations => organizations,
+            :token => CFoundry::AuthToken.new("bearer some-access-token")
+        }
+        let(:organization) { fake :organization, :users => [user] }
+        let(:user) { fake :user }
+
+        shared_examples_for :method_clearing_the_token_file do
+          it "sets the new organization in the token file" do
+            subject
+            expect(tokens_yaml["https://api.some-domain.com"][:organization]).to eq(organizations.first.guid)
+          end
+
+          it "clears the space param from the token file" do
+            subject
+            expect(tokens_yaml["https://api.some-domain.com"][:space]).to be_nil
+          end
+        end
+
+        context "with one organization" do
+          let(:organizations) {
+            [ organization ]
+          }
+
+          it "does not prompt for an organization" do
+            dont_allow_ask("Organization", anything)
+            subject
+          end
+
+          it_behaves_like :method_clearing_the_token_file
+        end
+
+        context "with multiple organizations" do
+          let(:organizations) {
+            [ organization, OpenStruct.new(:name => 'My Org 2', :guid => 'organization-id-2') ]
+          }
+
+          before do
+            stub_ask("Organization", anything) { organizations.first }
+          end
+
+          it "prompts for organization" do
+            mock_ask("Organization", anything) { organizations.first }
+            subject
+          end
+
+          it_behaves_like :method_clearing_the_token_file
+        end
+      end
+    end
+
+    context 'when there is no target' do
+      let(:client) { nil }
+      let(:stub_precondition?) { false }
+
+      it "tells the user to select a target" do
+        subject
+        expect(error_output).to say("Please select a target with 'cf target'.")
+      end
+    end
+  end
+end

data/spec/cf/cli/start/logout_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe CF::Start::Logout do
+  let(:client) { fake_client }
+
+  before do
+    any_instance_of described_class do |cli|
+      stub(cli).client { client }
+    end
+  end
+
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:logout] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Log out from the target" }
+      it { expect(Mothership::Help.group(:start)).to include(subject) }
+    end
+  end
+
+  describe "running the command" do
+    subject { cf ["logout"] }
+
+    context "when there is a target" do
+      let(:info) { { client.target => "x", "abc" => "x" } }
+
+      before do
+        any_instance_of CF::CLI do |cli|
+          stub(cli).targets_info { info }
+          stub(cli).client_target { client.target }
+        end
+      end
+
+      it "removes the target info from the tokens file" do
+        expect {
+          subject
+        }.to change { info }.to("abc" => "x")
+      end
+    end
+
+    context "when there is no target" do
+      let(:client) { nil }
+      it_behaves_like "an error that gets passed through",
+        :with_exception => CF::UserError,
+        :with_message => "Please select a target with 'cf target'."
+    end
+  end
+end
+

data/spec/cf/cli/start/target_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require "webmock/rspec"
+
+command CF::Start::Target do
+  let(:client) { fake_client :apps => [app] }
+  let(:app) { fake :app }
+
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:target] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Set or display the target cloud, organization, and space" }
+      specify { expect(Mothership::Help.group(:start)).to include(subject) }
+    end
+
+    include_examples 'inputs must have descriptions'
+
+    describe 'flags' do
+      subject { command.flags }
+
+      its(["-o"]) { should eq :organization }
+      its(["--org"]) { should eq :organization }
+      its(["-s"]) { should eq :space }
+    end
+
+    describe 'arguments' do
+      subject(:arguments) { command.arguments }
+      it 'have the correct commands' do
+        expect(arguments).to eq [{:type => :optional, :value => nil, :name => :url}]
+      end
+    end
+  end
+
+  describe 'running the command' do
+    stub_home_dir_with { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
+
+    context "when the user is authenticated and has an organization" do
+      let(:tokens_file_path) { '~/.cf/tokens.yml' }
+      let(:organizations) {
+        [ fake(:organization, :name => 'My Org', :guid => 'organization-id-1', :users => [user], :spaces => spaces),
+          fake(:organization, :name => 'My Org 2', :guid => 'organization-id-2') ]
+      }
+      let(:spaces) {
+        [ fake(:space, :name => 'Development', :guid => 'space-id-1'),
+          fake(:space, :name => 'Staging',     :guid => 'space-id-2') ]
+      }
+
+      let(:user) { stub! }
+      let(:organization) { organizations.first }
+      let(:client) do
+        fake_client :frameworks => fake_list(:framework, 3),
+          :organizations => organizations,
+          :token => CFoundry::AuthToken.new("bearer some-access-token")
+      end
+
+      before do
+        write_token_file({:space => "space-id-1", :organization => "organization-id-1"})
+        stub(client).current_user { user }
+        stub(client).organization { organization }
+        stub(client).current_organization { organization }
+        any_instance_of(described_class) do |instance|
+          stub(instance).client { client }
+        end
+      end
+
+      describe "switching the target" do
+        let(:target) { "some-valid-target.com" }
+        subject { cf ["target", target] }
+
+        context "when the target is not valid" do
+          before { WebMock.stub_request(:get, "http://#{target}/info").to_return(:body => "{}") }
+
+          it "should still be able to switch to a valid target after that" do
+            subject
+          end
+        end
+
+        context "when the target is valid but the connection is refused" do
+          it "shows a pretty error message" do
+            any_instance_of(CFoundry::Client) do |cli|
+              stub(cli).info { raise CFoundry::TargetRefused, "foo" }
+            end
+
+            subject
+            expect(error_output).to say("Target refused connection.")
+          end
+        end
+
+        context "when the uri is malformed" do
+          it "shows a pretty error message" do
+            any_instance_of(CFoundry::Client) do |cli|
+              stub(cli).info { raise CFoundry::InvalidTarget.new(target) }
+            end
+
+            subject
+            expect(error_output).to say("Invalid target URI.")
+          end
+        end
+      end
+
+      describe "switching the space" do
+        let(:space) { spaces.last }
+        let(:tokens_yaml) { YAML.load_file(File.expand_path(tokens_file_path)) }
+        let(:tokens_file_path) { '~/.cf/tokens.yml' }
+
+        def run_command
+          cf %W[target -s #{space.name}]
+        end
+
+        it "should not reprompt for organization" do
+          dont_allow_ask("Organization", anything)
+          run_command
+        end
+
+        it "sets the space param in the token file" do
+          run_command
+          expect(tokens_yaml["https://api.some-domain.com"][:space]).to be == 'space-id-2'
+        end
+      end
+    end
+  end
+end