startapp 0.1.6

data/spec/rhc/auth_spec.rb

@@ -0,0 +1,442 @@
+require 'spec_helper'
+require 'base64'
+require 'rhc/commands'
+
+describe RHC::Auth::Basic do
+  let(:user){ 'test_user' }
+  let(:password){ 'test pass' }
+  let(:auth_hash){ {:user => user, :password => password} }
+  let(:options){ (o = Commander::Command::Options.new).default(default_options); o }
+  let(:default_options){ {} }
+  let(:client){ double(:supports_sessions? => false) }
+
+  its(:username){ should be_nil }
+  its(:username?){ should be_false }
+  its(:password){ should be_nil }
+  its(:options){ should_not be_nil }
+  its(:can_authenticate?){ should be_false }
+  its(:openshift_server){ should == 'broker.startapp.bg' }
+
+  def resolved(hash)
+    hash.each_pair do |k,v|
+      hash[k] = v.call if v.is_a? Proc
+    end
+    hash
+  end
+
+  context "with user options" do
+    subject{ described_class.new(options) }
+
+    its(:username){ should be_nil }
+    its(:username?){ should be_false }
+    its(:password){ should be_nil }
+    its(:options){ should equal(options) }
+
+    context "that include user info" do
+      let(:default_options){ {:rhlogin => user, :password => password} }
+
+      its(:username){ should == user }
+      its(:username?){ should be_true }
+      its(:password){ should == password }
+      its(:can_authenticate?){ should be_true }
+    end
+
+    context "that includes server" do
+      let(:default_options){ {:server => 'test.com'} }
+
+      its(:openshift_server){ should == 'test.com' }
+      it do
+        subject.should_receive(:ask).with("Login to test.com: ").and_return(user)
+        subject.send(:ask_username).should == user
+      end
+    end
+
+    context "with --noprompt" do
+      let(:default_options){ {:noprompt => true} }
+
+      its(:ask_username){ should be_false }
+      its(:ask_password){ should be_false }
+      its(:username?){ should be_false }
+      it("should not retry") do
+        subject.should_not_receive(:ask_username)
+        subject.retry_auth?(double(:status => 401), client).should be_false
+      end
+    end
+  end
+
+  context "when initialized with a hash" do
+    subject{ described_class.new({:rhlogin => user, :password => password}) }
+    its(:username){ should == user }
+    its(:password){ should == password }
+  end
+
+
+  describe "#ask_username" do
+    before{ subject.should_receive(:openshift_server).and_return('test.com') }
+    before{ subject.should_receive(:ask).with("Login to test.com: ").and_return(user) }
+
+    it do
+      subject.send(:ask_username).should == user
+      subject.send(:username).should == user
+    end
+
+    context "with a different user" do
+      subject{ described_class.new('other', nil) }
+      it do
+        subject.send(:ask_username).should == user
+        subject.send(:username).should == user
+      end
+    end
+  end
+
+  describe "#ask_password" do
+    before{ subject.should_receive(:ask).with("Password: ").and_return(password) }
+    it do
+      subject.send(:ask_password).should == password
+      subject.send(:password).should == password
+    end
+
+    context "with a different password" do
+      subject{ described_class.new(user, 'other') }
+      it do
+        subject.send(:ask_password).should == password
+        subject.send(:password).should == password
+      end
+    end
+  end
+
+  describe "#to_request" do
+    let(:request){ {} }
+
+    context "when the request is lazy" do
+      let(:request){ {:lazy_auth => true} }
+      before{ subject.should_receive(:ask_username).never }
+      before{ subject.should_receive(:ask_password).never }
+
+      it { subject.to_request(request).should == request }
+    end
+
+    context "when password and user are provided" do
+      subject{ described_class.new(user, password) }
+
+      it { subject.to_request(request).should equal(request) }
+      it { resolved(subject.to_request(request)).should == auth_hash }
+
+      context "when the request is lazy" do
+        let(:request){ {:lazy_auth => true} }
+
+        it { subject.to_request(request).should == auth_hash.merge(request) }
+      end
+    end
+
+    context "when password is not provided" do
+      subject{ described_class.new(user, nil) }
+
+      its(:password){ should be_nil }
+      it "should ask for the password" do
+        subject.should_receive(:ask_password).and_return(password)
+        resolved(subject.to_request(request)).should == auth_hash
+      end
+      it "should remember the password" do
+        subject.should_receive(:ask_password).and_return(password)
+        subject.to_request(request)
+        resolved(subject.to_request(request)).should == auth_hash
+      end
+
+      context "when the request is lazy" do
+        let(:request){ {:lazy_auth => true} }
+        before{ subject.should_receive(:ask_password).never }
+
+        it { subject.to_request(request).should == auth_hash.merge(request) }
+      end
+    end
+
+    context "when user is not provided" do
+      subject{ described_class.new(nil, password) }
+
+      its(:username){ should be_nil }
+      it "should ask for the username" do
+        subject.should_receive(:ask_username).and_return(user)
+        resolved(subject.to_request(request)).should == auth_hash
+      end
+      it "should remember the username" do
+        subject.should_receive(:ask_username).and_return(user)
+        subject.to_request(request)
+        resolved(subject.to_request(request)).should == auth_hash
+      end
+
+      context "when the request is lazy" do
+        let(:request){ {:lazy_auth => true} }
+        before{ subject.should_receive(:ask_username).never }
+
+        it { subject.to_request(request).should == auth_hash.merge(request) }
+      end
+    end
+  end
+
+  describe "#retry_auth?" do
+    context "when the response succeeds" do
+      let(:response){ double(:cookies => {}, :status => 200) }
+
+      it{ subject.retry_auth?(response, client).should be_false }
+    end
+    context "when the response succeeds with a cookie" do
+      let(:response){ double(:cookies => [double(:name => 'rh_sso', :value => '1')], :status => 200) }
+      it{ subject.retry_auth?(response, client).should be_false }
+    end
+    context "when the response requires authentication" do
+      let(:response){ double(:status => 401) }
+
+      context "with no user and no password" do
+        subject{ described_class.new(nil, nil) }
+        it("should ask for user and password") do
+          subject.should_receive(:ask_username).and_return(user)
+          subject.should_receive(:ask_password).and_return(password)
+          subject.retry_auth?(response, client).should be_true
+        end
+      end
+
+      context "with user and no password" do
+        subject{ described_class.new(user, nil) }
+        it("should ask for password only") do
+          subject.should_receive(:ask_password).and_return(password)
+          subject.retry_auth?(response, client).should be_true
+        end
+        it("should ask for password twice") do
+          subject.should_receive(:ask_password).twice.and_return(password)
+          subject.retry_auth?(response, client).should be_true
+          subject.retry_auth?(response, client).should be_true
+        end
+      end
+
+      context "with user and password" do
+        subject{ described_class.new(user, password) }
+        it("should not prompt for reauthentication") do
+          subject.should_not_receive(:ask_password)
+          subject.should_receive(:error).with("Username or password is not correct")
+          subject.retry_auth?(response, client).should be_false
+        end
+      end
+    end
+  end
+end
+
+describe RHC::Auth::Token do
+  subject{ described_class.new(options) }
+
+  let(:token){ 'a_token' }
+  let(:options){ (o = Commander::Command::Options.new).default(default_options); o }
+  let(:default_options){ {} }
+  let(:client){ double(:supports_sessions? => false) }
+  let(:auth){ nil }
+  let(:store){ nil }
+
+  its(:username){ should be_nil }
+  its(:options){ should_not be_nil }
+  its(:can_authenticate?){ should be_false }
+  its(:openshift_server){ should == 'broker.startapp.bg' }
+
+  context "with user options" do
+    its(:username){ should be_nil }
+    its(:options){ should equal(options) }
+
+    context "that include token" do
+      let(:default_options){ {:token => token} }
+      its(:can_authenticate?){ should be_true }
+    end
+
+    context "that includes server" do
+      let(:default_options){ {:server => 'test.com'} }
+      its(:openshift_server){ should == 'test.com' }
+    end
+
+    context "with --noprompt" do
+      let(:default_options){ {:noprompt => true} }
+
+      its(:username){ should be_nil }
+      it("should not retry") do
+      end
+    end
+  end
+
+  context "when initialized with a hash" do
+    subject{ described_class.new({:token => token}) }
+    its(:token){ should == token }
+  end
+
+  context "when initialized with a string" do
+    subject{ described_class.new(token) }
+    its(:token){ should == token }
+  end
+
+  context "when initialized with an auth object" do
+    subject{ described_class.new(nil, auth) }
+    let(:auth){ double(:username => 'foo') }
+    its(:username){ should == 'foo' }
+  end
+
+  context "when initialized with a store" do
+    subject{ described_class.new(nil, nil, store) }
+    let(:store){ double }
+    before{ store.should_receive(:get).with(nil, 'broker.startapp.bg').and_return(token) }
+    it("should read the token for the user") do
+      subject.send(:token).should == token
+    end
+  end
+
+  describe "#save" do
+    subject{ described_class.new(nil, nil, store) }
+    context "when store is set" do
+      let(:store){ double(:get => nil) }
+      it("should call put on store") do
+        subject.should_receive(:username).and_return('foo')
+        subject.should_receive(:openshift_server).and_return('bar')
+        store.should_receive(:put).with('foo', 'bar', token)
+        subject.save(token)
+      end
+    end
+    context "when store is nil" do
+      it("should skip calling store"){ subject.save(token) }
+    end
+    after{ subject.instance_variable_get(:@token).should == token }
+  end
+
+  describe "#to_request" do
+    let(:request){ {} }
+    subject{ described_class.new(token, auth) }
+
+    context "when token is provided" do
+      it("should pass bearer token to the server"){ subject.to_request(request).should == {:headers => {'authorization' => "Bearer #{token}"}} }
+
+      context "when the request is lazy" do
+        let(:request){ {:lazy_auth => true} }
+        it("should pass bearer token to the server"){ subject.to_request(request).should == {:lazy_auth => true, :headers => {'authorization' => "Bearer #{token}"}} }
+      end
+    end
+
+    context "when token is not provided" do
+      subject{ described_class.new(nil) }
+
+      it("should pass not bearer token to the server"){ subject.to_request(request).should == {} }
+    end
+
+    context "when a parent auth class is passed" do
+      subject{ described_class.new(nil, auth) }
+      let(:auth){ double }
+      it("should invoke the parent") do
+        auth.should_receive(:to_request).with(request).and_return(request)
+        subject.to_request(request).should == request
+      end
+    end
+  end
+
+  describe "#retry_auth?" do
+    subject{ described_class.new(token, auth) }
+
+    context "when the response succeeds" do
+      let(:response){ double(:cookies => {}, :status => 200) }
+      it{ subject.retry_auth?(response, client).should be_false }
+    end
+
+    context "when the response requires authentication" do
+      let(:response){ double(:status => 401) }
+
+      context "with no token" do
+        subject{ described_class.new(nil, nil) }
+        it("should return false"){ subject.retry_auth?(response, client).should be_false }
+      end
+
+      context "when a nested auth object can't authenticate" do
+        let(:auth){ double(:can_authenticate? => false) }
+        it("should raise an error"){ expect{ subject.retry_auth?(response, client) }.to raise_error(RHC::Rest::TokenExpiredOrInvalid) }
+      end
+
+      context "with a nested auth object" do
+        let(:auth){ double('nested_auth', :can_authenticate? => true) }
+        subject{ described_class.new(options, auth) }
+
+        it("should not use token auth") do
+          auth.should_receive(:retry_auth?).with(response, client).and_return true
+          subject.retry_auth?(response, client).should be_true
+        end
+
+        context "when noprompt is requested" do
+          let(:default_options){ {:token => token, :noprompt => true} }
+          it("should raise an error"){ expect{ subject.retry_auth?(response, client) }.to raise_error(RHC::Rest::TokenExpiredOrInvalid) }
+        end
+
+        context "when authorization tokens are enabled locally" do
+          let(:default_options){ {:use_authorization_tokens => true} }
+
+          context "without session support" do
+            let(:default_options){ {:use_authorization_tokens => true, :token => 'foo'} }
+            let(:client){ double('client', :supports_sessions? => false) }
+
+            it("should invoke raise an error on retry because sessions are not supported") do
+              expect{ subject.retry_auth?(response, client) }.to raise_error RHC::Rest::AuthorizationsNotSupported
+            end
+          end
+
+          context "we expect a warning and a call to client" do
+            let(:auth_token){ nil }
+            let(:client){ double('client', :supports_sessions? => true) }
+            before{ client.should_receive(:new_session).with(:auth => auth).and_return(auth_token) }
+
+            it("should print a message") do
+              subject.should_receive(:info).with("Please sign in to start a new session to #{subject.openshift_server}.")
+              auth.should_receive(:retry_auth?).with(response, client).and_return true
+              subject.retry_auth?(response, client).should be_true
+            end
+
+            context "with a token" do
+              let(:default_options){ {:use_authorization_tokens => true, :token => 'foo'} }
+              it("should invoke raise an error on retry because sessions are not supported") do
+                subject.should_receive(:warn).with("Your authorization token has expired. Please sign in now to continue on #{subject.openshift_server}.")
+                auth.should_receive(:retry_auth?).with(response, client).and_return true
+                subject.retry_auth?(response, client).should be_true
+                #expect{ subject.retry_auth?(response, client) }.to raise_error RHC::Rest::AuthorizationsNotSupported
+              end
+            end
+
+            context "when the token request fails" do
+              before{ subject.should_receive(:info).with("Please sign in to start a new session to #{subject.openshift_server}.") }
+              it("should invoke retry on the parent") do
+                auth.should_receive(:retry_auth?).with(response, client).and_return false
+                subject.retry_auth?(response, client).should be_false
+              end
+            end
+
+            context "when the token request succeeds" do
+              let(:auth_token){ double('auth_token', :token => 'bar') }
+              before{ subject.should_receive(:info).with("Please sign in to start a new session to #{subject.openshift_server}.") }
+              it("should save the token and return true") do
+                subject.should_receive(:save).with(auth_token.token).and_return true
+                subject.retry_auth?(response, client).should be_true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+describe RHC::Auth::TokenStore do
+  subject{ described_class.new(dir) }
+  let(:dir){ Dir.mktmpdir }
+
+  context "when a key is stored" do
+    before{ subject.put('foo', 'bar', 'token') }
+    it("can be retrieved"){ subject.get('foo', 'bar').should == 'token' }
+  end
+
+  it("should handle missing files"){ subject.get('foo', 'other').should be_nil }
+  it("should put a file on disk"){ expect{ subject.put('test', 'server', 'value') }.to change{ Dir.entries(dir).length }.by(1) }
+
+  describe "#clear" do
+    before{ subject.put('test', 'server2', 'value2') }
+    it("should return true"){ subject.clear.should be_true }
+    it("should empty the directory"){ expect{ subject.clear }.to change{ Dir.entries(dir).length }.by_at_least(-1) }
+    after{ Dir.entries(dir).length.should == 2 }
+  end
+end

data/spec/rhc/cli_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+require 'rhc/wizard'
+
+describe RHC::CLI do
+
+  shared_examples_for 'a global help page' do
+    let(:arguments) { @arguments or raise "no arguments" }
+    it('should contain the program description') { run_output.should =~ /Command line interface for StartApp/ }
+    it('should describe getting started') { run_output.should =~ /Getting started:/ }
+    it('should describe basic command') { run_output.should =~ /Working with apps:/ }
+    it('should mention the help command') { run_output.should =~ /See 'app help <command>'/ }
+    it('should mention the help options command') { run_output.should =~ /app help options/ }
+  end
+
+  shared_examples_for 'a first run wizard' do
+    let(:arguments) { @arguments or raise "no arguments" }
+    let!(:wizard){ RHC::Wizard.new }
+    before{ RHC::Wizard.should_receive(:new).and_return(wizard) }
+    it('should create and run a new wizard') { expect{ run }.to call(:run).on(wizard) }
+  end
+
+  shared_examples_for 'a help page' do
+    let(:arguments) { @arguments or raise "no arguments" }
+    it('should contain the program description') { run_output.should =~ /Command line interface for StartApp/ }
+    it('should contain the global options') { run_output.should =~ /Global Options/ }
+    it('should provide a --config switch') { run_output.should =~ /\-\-config FILE/ }
+  end
+
+  shared_examples_for 'a list of all commands' do
+    let(:arguments) { @arguments or raise "no arguments" }
+    it('should contain a message') { run_output.should =~ /Showing all commands/ }
+    it('should contain command help') { run_output.should =~ /Create an application./ }
+    it('should contain aliases') { run_output.should =~ /\(also/ }
+  end
+
+  shared_examples_for 'a list of commands' do
+    let(:arguments) { @arguments or raise "no arguments" }
+    it('should contain a message') { run_output.should =~ /Showing commands matching '/ }
+    it('should contain command help') { run_output.should =~ /Create an application./ }
+    it('should contain aliases') { run_output.should =~ /\(also/ }
+  end
+
+  shared_examples_for 'a command-line options help page' do
+    let(:arguments) { @arguments or raise "no arguments" }
+    it('should contain an introduction') { run_output.should =~ /The following options can be passed to any/ }
+    it('should reference the configuration') { run_output.should match(".startapp/express.conf") }
+    it('should describe the --config switch') { run_output.should =~ /\-\-config FILE/ }
+    it('should describe the --ssl-version switch') { run_output.should =~ /\-\-ssl\-version VERSION/ }
+  end
+
+  shared_examples_for 'an invalid command' do
+    let(:arguments) { @arguments }
+    it('should contain the invalid command message') { run_output.should =~ /is not recognized/ }
+    it('should contain the arguments') { run_output.should include(@arguments[0]) }
+    it('should reference --help') { run_output.should =~ / help\b/ }
+  end
+
+  shared_examples_for 'version output' do
+    let(:arguments) { @arguments }
+    it 'should contain version output' do
+      run_output.should =~ /app \d+\.\d+(:?\.d+)?/
+    end
+  end
+
+  before{ base_config }
+
+  describe "--version" do
+    context "by itself" do
+      before :each do
+        @arguments = ['--version']
+      end
+      it_should_behave_like 'version output'
+    end
+  end
+
+  describe '#start' do
+    before{ RHC::Wizard.stub(:has_configuration?).and_return(true) }
+
+    context 'with no arguments' do
+      before(:each) { @arguments = [] }
+      it_should_behave_like 'a global help page'
+
+      context "without a config file" do
+        it_should_behave_like 'a global help page'
+      end
+    end
+
+    context 'with an ambiguous option' do
+      let(:arguments){ ['help', '-s'] }
+      it('should describe an ambiguous error'){ run_output.should match("The option -s is ambiguous. You will need to specify the entire option.") }
+    end
+
+    context 'with an invalid command' do
+      before(:each) { @arguments = ['invalidcommand'] }
+      it_should_behave_like 'an invalid command'
+    end
+
+    context 'with --help and invalid command' do
+      before(:each) { @arguments = ['invalidcommand', '--help'] }
+      it_should_behave_like 'an invalid command'
+    end
+
+    context 'with help and invalid command' do
+      before(:each) { @arguments = ['help', 'invalidcommand'] }
+      it_should_behave_like 'an invalid command'
+    end
+
+    context 'with help commands' do
+      before(:each) { @arguments = ['help', 'commands'] }
+      it_should_behave_like 'a list of all commands'
+    end
+
+    context 'with help and possible command matches' do
+      before(:each) { @arguments = ['help', 'app c'] }
+      it_should_behave_like 'a list of commands'
+    end
+
+    context 'with help and a single matching command segment' do
+      let(:arguments){ ['help', 'app creat'] }
+      it("prints the usage for the command"){ run_output.should match('Usage: app app-create <') }
+      it("prints part of the description for the command"){ run_output.should match('StartApp runs the components of your') }
+      it("prints a local option"){ run_output.should match('--namespace NAME') }
+    end
+
+    context 'with --help' do
+      before(:each){ @arguments = ['--help'] }
+      it_should_behave_like 'a global help page'
+
+      context 'without a config file' do
+        before{ RHC::Wizard.stub(:has_configuration?).and_return(false) }
+        it_should_behave_like 'a global help page'
+      end
+    end
+
+    context 'with -h' do
+      before(:each){ @arguments = ['-h'] }
+      it_should_behave_like 'a global help page'
+    end
+
+    context 'with help' do
+      before(:each){ @arguments = ['help'] }
+      it_should_behave_like 'a global help page'
+    end
+
+    context 'with help options' do
+      before(:each){ @arguments = ['help', 'options'] }
+      it_should_behave_like 'a command-line options help page'
+    end
+  end
+
+  describe 'option provided twice' do
+    before{ user_config }
+    let!(:rest_client){ MockRestClient.new }
+    before(:each) do
+      domain = rest_client.add_domain("mock_domain")
+      @app = domain.add_application("app1", "mock_type")
+    end
+    context 'when run with -a provided twice, last being the valid one' do
+      let(:arguments) { ['cartridge', 'remove', 'mock_cart-1', '--confirm', '--trace','-a', 'app2', '-a', 'app1', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password'] }
+      it "should remove cartridge" do
+        @app.add_cartridge('mock_cart-1')
+        expect { run }.to exit_with_code(0)
+      end
+    end
+    context 'when run with -a provided twice, last not being the valid one' do
+      let(:arguments) { ['cartridge', 'remove', 'mock_cart-1', '--confirm', '--trace','-a', 'app1', '-a', 'app2', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password'] }
+      it "should raise an application not found exception" do
+        expect{ run }.to raise_error(RHC::Rest::ApplicationNotFoundException)
+      end
+    end
+  end
+
+  describe '#set_terminal' do
+    before(:each) { mock_terminal }
+    it('should update $terminal.wrap_at') do
+      $stdout.should_receive(:tty?).twice.and_return(true)
+      HighLine::SystemExtensions.should_receive(:terminal_size).and_return([5])
+      expect { RHC::CLI.set_terminal }.to change($terminal, :wrap_at)
+    end
+    it('should not update $terminal.page_at') do
+      $stdout.should_receive(:tty?).twice.and_return(true)
+      expect { RHC::CLI.set_terminal }.to_not change($terminal, :page_at)
+    end
+  end
+
+end