rhc 1.2.7 → 1.3.8

data/spec/rhc/targz_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'rhc/targz'
+require 'rhc/tar_gz'
 
 describe RHC::TarGz do
 

data/spec/rhc/wizard_spec.rb

@@ -5,651 +5,502 @@ require 'rhc/vendor/parseconfig'
 require 'rhc/config'
 require 'ostruct'
 require 'rest_spec_helper'
+require 'wizard_spec_helper'
+require 'tmpdir'
+
+# Allow to define the id method
+OpenStruct.__send__(:define_method, :id) { @table[:id] } if RUBY_VERSION.to_f == 1.8
 
 describe RHC::Wizard do
-  before(:all) do
-    mock_terminal
-    RHC::Config.set_defaults
-    FakeFS.activate!
-    FakeFS::FileSystem.clear
-  end
 
-  after(:all) do
-    FakeFS.deactivate!
+  def mock_config
+    RHC::Config.stub(:home_dir).and_return('/home/mock_user')
   end
 
-  context "First run of rhc" do
-    before(:all) do
-      @wizard = FirstRunWizardDriver.new
-    end
-
-    it "should print out first run greeting" do
-      @wizard.run_next_stage
-      greeting = $terminal.read
-      greeting.count("\n").should >= 3
-      greeting.should match(/OpenShift Client Tools \(RHC\) Setup Wizard/)
-    end
-
-    it "should ask for login and hide password input" do
-      @wizard.stub_rhc_client_new
-      # queue up input
-      $terminal.write_line "#{@wizard.mock_user}"
-      $terminal.write_line "password"
-
-
-      @wizard.run_next_stage
-
-      output = $terminal.read
-      output.should match("Login to ")
-      output.should match(/Password: [\*]{8}$/)
-    end
-
-    it "should write out a config" do
-      File.exists?(@wizard.config_path).should be false
-      @wizard.run_next_stage
-      File.readable?(@wizard.config_path).should be true
-      cp = RHC::Vendor::ParseConfig.new @wizard.config_path
-      cp["default_rhlogin"].should == @wizard.mock_user
-      cp["libra_server"].should == @wizard.libra_server
-    end
-
-    it "should write out generated ssh keys" do
-      @wizard.setup_mock_ssh
-      private_key_file = File.join(@wizard.ssh_dir, "id_rsa")
-      public_key_file = File.join(@wizard.ssh_dir, "id_rsa.pub")
-      File.exists?(private_key_file).should be false
-      File.exists?(public_key_file).should be false
-      @wizard.run_next_stage
-      File.exists?(private_key_file).should be true
-      File.exists?(public_key_file).should be true
-    end
-
-    it "should ask to upload ssh keys" do
-      @rest_client.stub(:get_ssh_keys) { @wizard.get_mock_key_data }
-      $terminal.write_line('yes')
-      @wizard.stub_rhc_client_new
-      @wizard.ssh_keys = []
-      @wizard.run_next_stage
-    end
-
-    it "should check for client tools" do
-      @wizard.setup_mock_has_git(true)
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Checking for git \.\.\. found")
-    end
-
-    it "should ask for a namespace" do
-      $terminal.write_line("thisnamespaceistoobigandhastoomanycharacterstobevalid")
-
-      $terminal.write_line("invalidnamespace")
-      $terminal.write_line("testnamespace")
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Checking for your namespace \.\.\. not found")
-    end
-
-    it "should show app creation commands" do
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match 'Below is a list of'
-    end
+  let(:options){ (o = Commander::Command::Options.new).default(default_options); o }
+  let(:config){ RHC::Config.new.tap{ |c| c.stub(:home_dir).and_return('/home/mock_user') } }
+  let(:default_options){ {} }
 
-    it "should show a thank you message" do
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("The OpenShift client tools have been configured on your computer")
-    end
+  describe "#finalize_stage" do
+    subject{ RHC::Wizard.new(config, options) }
+    before{ subject.should_receive(:say).with(/The OpenShift client tools have been configured/) }
+    it{ subject.send(:finalize_stage).should be_true }
   end
 
-  context "Repeat run of rhc setup without anything set" do
-    before(:all) do
-      @wizard = RerunWizardDriver.new
-    end
-
-    it "should print out repeat run greeting" do
-      @wizard.run_next_stage
-      greeting = $terminal.read
-      greeting.should match(/OpenShift Client Tools \(RHC\) Setup Wizard/)
-    end
-
-    it "should ask for login and hide password input" do
-      @wizard.stub_rhc_client_new
-      $terminal.write_line "#{@wizard.mock_user}"
-      $terminal.write_line "password"
-
-      @wizard.run_next_stage
-
-      output = $terminal.read
-      output.should match("Login to ")
-      output.should match(/Password: [\*]{8}$/)
-    end
-
-    it "should write out a config" do
-      File.exists?(@wizard.config_path).should be false
-      @wizard.run_next_stage
-      File.readable?(@wizard.config_path).should be true
-      cp = RHC::Vendor::ParseConfig.new @wizard.config_path
-      cp["default_rhlogin"].should == @wizard.mock_user
-      cp["libra_server"].should == @wizard.libra_server
-    end
-
-    it "should write out generated ssh keys" do
-      @wizard.setup_mock_ssh
-      private_key_file = File.join(@wizard.ssh_dir, "id_rsa")
-      public_key_file = File.join(@wizard.ssh_dir, "id_rsa.pub")
-      File.exists?(private_key_file).should be false
-      File.exists?(public_key_file).should be false
-      @wizard.run_next_stage
-      File.exists?(private_key_file).should be true
-      File.exists?(public_key_file).should be true
-    end
-
-    it "should upload ssh key as default" do
-      @rest_client.stub(:sshkeys) {[]}
-      @wizard.stub(:get_preferred_key_name) { 'default' }
-      $terminal.write_line('yes')
-      @wizard.run_next_stage
-    end
-
-    it "should check for client tools and print they need to be installed" do
-      @wizard.setup_mock_has_git(false)
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Checking for git \.\.\. needs to be installed")
-      output.should match("Automated installation of client tools is not supported for your platform")
-    end
-
-    it "should ask for a namespace" do
-      $terminal.write_line("testnamespace")
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Checking for your namespace \.\.\. not found")
-    end
-
-    it "should show app creation commands" do
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match 'Below is a list of'
-    end
-
-    it "should show a thank you message" do
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Thank you")
-    end
-  end
-
-  context "Repeat run of rhc setup with config set" do
-    before(:all) do
-      RHC::Config.set_defaults
-      @wizard = RerunWizardDriver.new
-      @wizard.setup_mock_config
-      @wizard.run_next_stage # we can skip testing the greeting
-    end
-
-    it "should ask for password input with default login" do
-      @wizard.stub_rhc_client_new
-
-      $terminal.write_line("") # hit enter for default
-      $terminal.write_line "password"
-
-      @wizard.run_next_stage
-
-      output = $terminal.read
-      output.should match("|#{@wizard.mock_user}|")
-    end
-
-    it "should write out a config" do
-      File.exists?(@wizard.config_path).should be true
-      @wizard.run_next_stage
-      File.readable?(@wizard.config_path).should be true
-      cp = RHC::Vendor::ParseConfig.new @wizard.config_path
-      cp["default_rhlogin"].should == @wizard.mock_user
-      cp["libra_server"].should == @wizard.libra_server
-    end
-
-    it "should write out generated ssh keys" do
-      @wizard.setup_mock_ssh
-      private_key_file = File.join(@wizard.ssh_dir, "id_rsa")
-      public_key_file = File.join(@wizard.ssh_dir, "id_rsa.pub")
-      File.exists?(private_key_file).should be false
-      File.exists?(public_key_file).should be false
-      @wizard.run_next_stage
-      File.exists?(private_key_file).should be true
-      File.exists?(public_key_file).should be true
-    end
-
-    it "should find out that you have not uploaded the default key and ask to name the key" do
-      key_data = @wizard.get_mock_key_data
-      @wizard.ssh_keys = key_data
-      key_name = '73ce2cc1'
-      
-      fingerprint, short_name = @wizard.get_key_fingerprint
-      @wizard.rest_client.stub(:find_key) { key_data.detect{|k| k.name == key_name} }
-      $terminal.write_line('yes')
-      $terminal.write_line(key_name) # answering with an existing key name
-      @wizard.run_next_stage
-      output = $terminal.read
-      key_data.each do |key|
-        output.should match("Name: #{key.name}")
-        output.should match("Fingerprint: #{key.fingerprint}")
+  describe "#test_ssh_connectivity" do
+    subject{ RHC::Wizard.new(config, options) }
+    let(:app) do
+      app = Object.new
+      app.should_receive(:host).at_least(1).and_return('foo.com')
+      app.should_receive(:uuid).at_least(1).and_return('uuid')
+      app
+    end
+    let(:ssh) do
+      ssh = Object.new
+      ssh.should_receive(:close)
+      ssh
+    end
+
+    it "should not attempt an SSH connection" do
+      subject.should_receive(:ssh_key_uploaded?).and_return(true)
+      subject.should_receive(:applications).and_return([])
+      subject.send(:test_ssh_connectivity).should be_true
+    end
+    it "should attempt an SSH connection to the first app" do
+      subject.should_receive(:ssh_key_uploaded?).and_return(true)
+      subject.should_receive(:applications).and_return([app])
+      Net::SSH.should_receive(:start).with(app.host, app.uuid, {:timeout => 60}).and_return(ssh)
+      subject.send(:test_ssh_connectivity).should be_true
+    end
+    it "should handle a failed connection" do
+      subject.should_receive(:ssh_key_uploaded?).and_return(true)
+      subject.should_receive(:applications).and_return([app])
+      Net::SSH.should_receive(:start).and_raise(StandardError.new('an_error'))
+      subject.should_receive(:report_result) do |ssh, msg|
+        ssh.should be_nil
+        msg.should match('An SSH connection could not be established')
+        msg.should match('an_error')
       end
-      output.should match("|#{short_name}|") # prompt with the default name
-    end
-
-    it "should check for client tools and find them" do
-      @wizard.setup_mock_has_git(true)
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Checking for git \.\.\. found")
-    end
-
-    it "should ask for a namespace" do
-      $terminal.write_line("testnamespace")
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Checking for your namespace \.\.\. not found")
-    end
-
-    it "should show app creation commands" do
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match 'Below is a list of'
-    end
-
-    it "should show a thank you message" do
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Thank you")
+      subject.send(:test_ssh_connectivity).should be_false
     end
   end
 
-  context "Repeat run of rhc setup with config and ssh keys set" do
-
-    before(:all) do
-      @wizard = RerunWizardDriver.new
-      @wizard.setup_mock_config
-      @wizard.setup_mock_ssh(true)
-      @wizard.run_next_stage # we can skip testing the greeting
-    end
-
-    it "should ask for password input with default login" do
-      @wizard.stub_rhc_client_new
-
-      $terminal.write_line("") # hit enter for default
-      $terminal.write_line "password"
+  describe "#login_stage" do
+    let(:user){ 'test_user' }
+    let(:password){ 'test pass' }
+    let(:rest_client){ stub }
+    let(:auth){ subject.send(:auth) }
 
-      @wizard.run_next_stage
+    subject{ RHC::Wizard.new(config, options) }
 
-      output = $terminal.read
-      output.should match("|#{@wizard.mock_user}|")
+    def expect_client_test
+      subject.should_receive(:new_client_for_options).ordered.and_return(rest_client)
+      rest_client.should_receive(:api).ordered
+      rest_client.should_receive(:user).ordered.and_return(true)
     end
-
-    it "should write out a config" do
-      File.exists?(@wizard.config_path).should be true
-      @wizard.run_next_stage
-      File.readable?(@wizard.config_path).should be true
-      cp = RHC::Vendor::ParseConfig.new @wizard.config_path
-      cp["default_rhlogin"].should == @wizard.mock_user
-      cp["libra_server"].should == @wizard.libra_server
+    def expect_raise_from_api(error)
+      #subject.send(:auth).should_receive(:ask).with("Using #{user} to login to openshift.redhat.com").and_return(username).ordered
+      #subject.send(:auth).should_receive(:ask).with("Password: ").and_return(password).ordered
+      subject.should_receive(:new_client_for_options).ordered.and_return(rest_client)
+      rest_client.should_receive(:api).ordered.and_raise(error)
     end
 
-    it "should check for ssh keys and find a match" do
-      @wizard.stub(:ssh_key_uploaded?) { true } # an SSH key already exists
-      @wizard.run_next_stage # key config is pretty much a noop here
-
-      # run the key check stage
-      @wizard.run_next_stage
+    it "should prompt for user and password" do
+      #auth.should_receive(:ask).with("Login to openshift.redhat.com: ").ordered.and_return(user)
+      #auth.should_receive(:ask).with("Password: ").ordered.and_return(password)
+      expect_client_test
 
-      output = $terminal.read
-      output.should_not match("ssh key must be uploaded")
+      subject.send(:login_stage).should be_true
     end
 
-    it "should check for client tools and find them" do
-      @wizard.setup_mock_has_git(true)
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Checking for git \.\.\. found")
-    end
-
-    it "should ask for a namespace" do
-      $terminal.write_line("testnamespace")
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Checking for your namespace \.\.\. not found")
-    end
+    context "with credentials" do
+      let(:default_options){ {:rhlogin => user, :password => password} }
 
-    it "should show app creation commands" do
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match 'Below is a list of'
-    end
-
-    it "should show a thank you message" do
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Thank you")
-    end
-  end
+      it "should warn about a self signed cert error" do
+        expect_raise_from_api(RHC::Rest::SelfSignedCertificate.new('reason', 'message'))
+        subject.should_receive(:warn).with(/server's certificate is self-signed/).ordered
+        subject.should_receive(:openshift_online_server?).ordered.and_return(true)
+        subject.should_receive(:warn).with(/server between you and OpenShift/).ordered
 
-  context "Repeat run of rhc setup with everything set" do
-    before(:all) do
-      @namespace = 'testnamespace'
-      @wizard = RerunWizardDriver.new
-      @rest_client = RestSpecHelper::MockRestClient.new
-      domain = @rest_client.add_domain(@namespace)
-      domain.add_application('test1', 'mock_standalone_cart-1')
-      domain.add_application('test2', 'mock_standalone_cart-2')
-      @wizard.setup_mock_config("old_mock_user@bar.baz")
-      @wizard.setup_mock_ssh(true)
-      @wizard.setup_mock_domain_and_applications(@namespace, 'test1' => :default, 'test2' => :default)
-      @wizard.run_next_stage # we can skip testing the greeting
-    end
-
-    it "should ask password input with default login(use a different one)" do
-      $terminal.write_line(@wizard.mock_user)
-      $terminal.write_line "password"
-
-      @wizard.run_next_stage
-
-      output = $terminal.read
-      output.should match("|old_mock_user@bar.baz|")
-    end
-
-    it "should write out a config" do
-      File.exists?(@wizard.config_path).should be true
-      @wizard.run_next_stage
-      File.readable?(@wizard.config_path).should be true
-      cp = RHC::Vendor::ParseConfig.new @wizard.config_path
-      cp["default_rhlogin"].should == @wizard.mock_user
-      cp["libra_server"].should == @wizard.libra_server
-    end
+        subject.send(:login_stage).should be_nil
+      end
 
-    it "should check for ssh keys, not find it on the server and update existing key" do
-      key_data = @wizard.get_mock_key_data
-      key_data.delete_if { |k| k.name == '73ce2cc1' }
-      key_name = 'default'
-      @rest_client.stub(:sshkeys) { key_data }
-      @rest_client.stub(:find_key) { key_data.detect {|k| k.name == key_name } }
+      it "should warn about a cert error for Online" do
+        expect_raise_from_api(RHC::Rest::CertificateVerificationFailed.new('reason', 'message'))
+        subject.should_receive(:warn).with(/server's certificate could not be verified/).ordered
+        subject.should_receive(:openshift_online_server?).ordered.and_return(true)
+        subject.should_receive(:warn).with(/server between you and OpenShift/).ordered
 
-      @wizard.run_next_stage # key config is pretty much a noop here
+        subject.send(:login_stage).should be_nil
+      end
 
-      $terminal.write_line('yes')
-      $terminal.write_line(key_name)
+      it "should warn about a cert error for custom server and continue" do
+        expect_raise_from_api(RHC::Rest::CertificateVerificationFailed.new('reason', 'message'))
+        subject.should_receive(:warn).with(/server's certificate could not be verified/).ordered
+        subject.should_receive(:openshift_online_server?).ordered.and_return(false)
+        subject.should_receive(:warn).with(/bypass this check/).ordered
+        subject.should_receive(:agree).with(/Connect without checking/).ordered.and_return(true)
+        expect_client_test
 
-      # run the key check stage
-      @wizard.run_next_stage
+        subject.send(:login_stage).should be_true
+        options.insecure.should be_true
+      end
 
-      output = $terminal.read
-      output.should match("Key with the name #{key_name} already exists. Updating")
-    end
+      it "should warn about a cert error for custom server and be cancelled" do
+        expect_raise_from_api(RHC::Rest::CertificateVerificationFailed.new('reason', 'message'))
+        subject.should_receive(:warn).with(/server's certificate could not be verified/).ordered
+        subject.should_receive(:openshift_online_server?).ordered.and_return(false)
+        subject.should_receive(:warn).with(/bypass this check/).ordered
+        subject.should_receive(:agree).with(/Connect without checking/).ordered.and_return(false)
 
-    it "should check for client tools and find them" do
-      @wizard.setup_mock_has_git(true)
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Checking for git \.\.\. found")
+        subject.send(:login_stage).should be_nil
+        options.insecure.should be_false
+      end
     end
+  end
 
-    it "should show namespace" do
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Checking for your namespace ... found namespace:")
-      output.should match(@namespace)
-    end
+  #TODO: Implement more stage level specs
 
-    it "should list apps" do
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("test1 - https://test1-#{@namespace}.#{@wizard.libra_server}/")
-      output.should match("test2 - https://test2-#{@namespace}.#{@wizard.libra_server}/")
-    end
+  context "when the wizard is run" do
+    subject{ RHC::RerunWizard.new(config, options) }
 
-    it "should show a thank you message" do
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Thank you")
+    before(:each) do
+      mock_terminal
+      FakeFS.activate!
+      FakeFS::FileSystem.clear
+      mock_config
+      RHC::Config.initialize
     end
-  end
 
-  context "Repeat run of rhc setup with everything set but platform set to Windows" do
-    before(:all) do
-      @wizard = RerunWizardDriver.new
-      @wizard.windows = true
-      @wizard.run_next_stage
+    after(:all) do
+      FakeFS.deactivate!
     end
 
-    it "should ask password input" do
-      @wizard.stub_rhc_client_new
-      # queue up input
-      $terminal.write_line "#{@wizard.mock_user}"
-      $terminal.write_line "password"
+    #after{ FileUtils.rm_rf(@tmpdir) if @tmpdir }
+    let(:home_dir){ '/home/mock_user' }#@tmpdir = Dir.mktmpdir }
+    let(:config){ RHC::Config.new.tap{ |c| c.stub(:home_dir).and_return(home_dir) } }
 
-      @wizard.run_next_stage
+    let(:options){ (o = Commander::Command::Options.new).default(default_options); o }
+    let(:default_options){ {:server => mock_uri} }
+    let(:username){ mock_user }
+    let(:password){ 'password' }
+    let(:user_auth){ {:user => username, :password => password} }
 
-      output = $terminal.read
-      output.should match("Login to ")
-      output.should match(/Password: [\*]{8}$/)
+    describe "#run" do
+      context "when a stage returns nil" do
+        before{ subject.stub(:greeting_stage).and_return(nil) }
+        it "should exit after that stage" do
+          subject.should_receive(:login_stage).never
+          subject.run.should be_nil
+        end
+      end
     end
 
-    it "should write out a config" do
-      File.exists?(@wizard.config_path).should be false
-      @wizard.run_next_stage
-      File.readable?(@wizard.config_path).should be true
-      cp = RHC::Vendor::ParseConfig.new @wizard.config_path
-      cp["default_rhlogin"].should == @wizard.mock_user
-      cp["libra_server"].should == @wizard.libra_server
-    end
+    context "with no settings" do
+      before do
+        stub_api
+        stub_user
+        stub_no_keys
+        stub_no_domains
+        stub_simple_carts
+      end
 
-    it "should check for ssh keys and decline uploading them" do
-      @wizard.setup_mock_ssh
-      @wizard.run_next_stage
-      RHC.stub(:get_ssh_keys) { {"keys" => [], "fingerprint" => nil} }
-      $terminal.write_line('no')
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("rhc sshkey")
-    end
+      it "should execute the minimal path" do
+        should_greet_user
+        should_challenge_for(username, password)
+        should_write_config
+        should_create_an_ssh_keypair
+        should_skip_uploading_key
+        should_find_git
+        should_not_find_problems
+        should_skip_creating_namespace
+        should_list_types_of_apps_to_create
+        should_be_done
+      end
 
-    it "should print out windows client tool info" do
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("Git for Windows")
-    end
+      context "on windows systems" do
+        before{ subject.stub(:windows?).and_return(true) }
+        it "should display windows info" do
+          should_greet_user
+          should_challenge_for(username, password)
+          should_write_config
+          should_create_an_ssh_keypair
+          should_skip_uploading_key
+          should_display_windows_info
+        end
+      end
 
-    it "should ask for namespace and decline entering one" do
-      $terminal.write_line("")
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("rhc domain create")
-    end
+      context "when the user enters a domain and uploads a key" do
+        before do
+          stub_create_default_key
+          stub_api_request(:post, 'broker/rest/domains', user_auth).
+            with(:body => /(thisnamespaceistoobig|invalidnamespace)/).
+            to_return({
+              :status => 409,
+              :body => {
+                :messages => [{:field => 'id', :severity => 'ERROR', :text => 'Too long', :exit_code => 123}]
+              }.to_json
+            })
+          stub_create_domain('testnamespace')
+        end
+        it "should create the domain" do
+          should_greet_user
+          should_challenge_for(username, password)
+          should_write_config
+          should_create_an_ssh_keypair
+          should_upload_default_key
+          should_find_git
+          should_not_find_problems
+          should_create_a_namespace
+          should_list_types_of_apps_to_create
+          should_be_done
+        end
+      end
 
-    it "should list apps without domain" do
-      @wizard.setup_mock_domain_and_applications(nil, 'test1' => nil, 'test2' => nil)
-      @wizard.run_next_stage
-      output = $terminal.read
-      output.should match("test1 - no public url")
-      output.should match("test2 - no public url")
-    end
+      context "when the user inputs incorrect authentication" do
+        before{ stub_api_request(:get, 'broker/rest/user', :user => username, :password => 'invalid').to_return(:status => 401) }
+        it "should prompt them again" do
+          should_greet_user
+
+          input_line username
+          input_line 'invalid'
+          input_line password
+          next_stage.should_not be_nil
+
+          last_output do |s|
+            s.should match("Login to ")
+            s.should match("Username or password is not correct")
+            s.scan("Password: *").length.should == 2
+          end
+        end
+      end
 
-  end
+      context "when the default key is not uploaded" do
+        before{ stub_one_key('a'); stub_update_key('a') }
+        it "should prompt for the new key" do
+          should_greet_user
+          should_challenge_for(username, password)
+          should_write_config
+          should_create_an_ssh_keypair
+
+          input_line 'yes'
+          input_line 'a'
+          next_stage
+          last_output do |s|
+            s.should match(/a \(type: ssh-rsa\)/)
+            s.should match("Fingerprint: #{rsa_key_fingerprint_public}")
+            s.should match(" name |a|")
+          end
+        end
+      end
 
-  context "Do a complete run through the wizard" do
-    before(:all) do
-      @wizard = FirstRunWizardDriver.new
+      context "when the default key already exists on the server" do
+        before{ setup_mock_ssh(true) }
+        before{ stub_mock_ssh_keys }
+
+        it "should prompt for the new key" do
+          should_greet_user
+          should_challenge_for(username, password)
+          should_write_config
+          should_not_create_an_ssh_keypair
+          should_find_matching_server_key
+        end
+      end
     end
 
-    it "should run" do
-      @wizard.libra_server = nil
-      @wizard.stub_rhc_client_new
-      @wizard.setup_mock_ssh
+    context "with login and existing domain and app" do
+      let(:default_options){ {:rhlogin => username, :server => mock_uri} }
+      subject{ RHC::RerunWizard.new(config, options) }
+
+      before do
+        stub_api(:user => username)
+        stub_user
+        stub_no_keys
+        stub_create_default_key
+        stub_api_request(:post, 'broker/rest/domains', user_auth).
+          with(:body => /(thisnamespaceistoobig|invalidnamespace)/).
+          to_return({
+            :status => 409,
+            :body => {
+              :messages => [{:field => 'id', :severity => 'ERROR', :text => 'Too long', :exit_code => 123}]
+            }.to_json
+          })
+        stub_one_domain('testnamespace')
+        stub_one_application('testnamespace', 'test1')
+        stub_simple_carts
+      end
 
-      RHC.stub(:get_ssh_keys) { {"keys" => [], "fingerprint" => nil} }
-      mock_carts = ['ruby', 'python', 'jbosseap']
-      @rest_client.stub(:cartridges) { mock_carts }
+      it "should skip steps that have already been completed" do
+        should_greet_user
+        should_challenge_for(nil, password)
+        should_write_config
+        should_create_an_ssh_keypair
+        should_upload_default_key
+        should_not_find_git
+        should_check_remote_server
+        should_find_a_namespace('testnamespace')
+        should_find_apps(['test1', 'testnamespace'])
+        should_be_done
+      end
 
-      $terminal.write_line "#{@wizard.mock_user}"
-      $terminal.write_line "password"
-      $terminal.write_line('no')
-      $terminal.write_line("")
+      context "with different config" do
+        let(:config_option){ setup_different_config }
+        let(:default_options){ {:rhlogin => username, :server => mock_uri, :config => config_option} }
 
-      @wizard.run().should be_true
+        it "should overwrite the config" do
+          should_greet_user
+          should_challenge_for(nil, password)
+          should_overwrite_config
+        end
+      end
     end
 
-    it "should fail" do
-      @wizard.stub_rhc_client_new
-      @wizard.stub(:login_stage) { nil }
-      @wizard.run().should be_nil
-    end
-  end
+    context "with SSHWizard" do
+      let(:default_options){ {:rhlogin => username, :password => password} }
+      let(:auth){ RHC::Auth::Basic.new(options) }
+      let(:rest_client){ RHC::Rest::Client.new(:server => mock_uri, :auth => auth) }
+      subject{ RHC::SSHWizard.new(rest_client, config, options) }
 
-  context "Check SSHWizard" do
-    it "should generate and upload keys since the user does not have them" do
-      wizard = SSHWizardDriver.new
-      key_name = 'default'
-      $terminal.write_line("yes\n#{key_name}\n")
+      before do
+        stub_api(user_auth)
+        stub_user
+      end
 
-      wizard.run().should be_true
+      context "with no server keys" do
+        before{ stub_no_keys }
+        before{ stub_create_default_key }
 
-      output = $terminal.read
-      output.should match("Uploading key '#{key_name}'")
-    end
+        it "should generate and upload keys since the user does not have them" do
+          input_line "yes"
+          input_line 'default'
+          input_line ""
 
-    it "should pass through since the user has keys already" do
-      wizard = SSHWizardDriver.new
-      wizard.stub(:ssh_key_uploaded?) { true }
-      wizard.run().should be_true
+          should_create_an_ssh_keypair
+          should_upload_default_key
 
-      output = $terminal.read
-      output.should == ""
-    end
-  end
+          #last_output.should match("Uploading key 'default'")
+        end
 
-  context "Check odds and ends" do
+        context "with default keys created" do
+          before{ setup_mock_ssh(true) }
+          it "should upload the default key" do
+            should_not_create_an_ssh_keypair
+            should_upload_default_key
+          end
+        end
+      end
 
-    it "should cause has_git? to catch an exception and return false" do
-      wizard = FirstRunWizardDriver.new
-      wizard.stub(:git_version_exec){ raise "Fake Exception" }
-      wizard.send(:has_git?).should be_false
+      context "with the server having the default key" do
+        before{ setup_mock_ssh(true) }
+        before{ stub_mock_ssh_keys }
+        it "should pass through since the user has keys already" do
+          subject.run.should be_true
+          last_output.should == ""
+        end
+      end
     end
 
-    it "should cause ssh_key_upload? to catch NoMethodError and call the fallback to get the fingerprint" do
-      wizard = RerunWizardDriver.new
-      Net::SSH::KeyFactory.stub(:load_public_key) { raise NoMethodError }
-      @fallback_run = false
-      wizard.stub(:ssh_keygen_fallback) { @fallback_run = true }
-      key_data = wizard.get_mock_key_data
-      @rest_client.stub(:sshkeys) { key_data }
+    context "Check odds and ends" do
+      before(:each) { mock_config }
+      let(:wizard){ RerunWizardDriver.new }
 
-      wizard.send(:ssh_key_uploaded?)
+      it "should cause ssh_key_upload? to catch NoMethodError and call the fallback to get the fingerprint" do
+        Net::SSH::KeyFactory.stub(:load_public_key) { raise NoMethodError }
+        @fallback_run = false
+        wizard.stub(:ssh_keygen_fallback) { @fallback_run = true }
+        key_data = wizard.get_mock_key_data
+        @rest_client.stub(:sshkeys) { key_data }
 
-      @fallback_run.should be_true
-    end
+        wizard.send(:ssh_key_uploaded?)
 
-    it "should cause upload_ssh_key to catch NoMethodError and call the fallback to get the fingerprint" do
-      wizard = RerunWizardDriver.new
-      wizard.ssh_keys = wizard.get_mock_key_data
-      @fallback_run = false
-      wizard.stub(:ssh_keygen_fallback) do
-        @fallback_run = true
-        [OpenStruct.new( :name => 'default', :fingerprint => 'AA:BB:CC:DD:EE:FF', :type => 'ssh-rsa' )]
+        @fallback_run.should be_true
       end
-      $?.stub(:exitstatus) { 255 }
-      Net::SSH::KeyFactory.stub(:load_public_key) { raise NoMethodError }
-
-      wizard.send(:upload_ssh_key).should be_false
 
-      output = $terminal.read
-      output.should match("Your ssh public key at .* is invalid or unreadable\.")
-      @fallback_run.should be_true
-    end
+      it "should cause upload_ssh_key to catch NoMethodError and call the fallback to get the fingerprint" do
+        wizard.ssh_keys = wizard.get_mock_key_data
+        @fallback_run = false
+        wizard.stub(:ssh_keygen_fallback) do
+          @fallback_run = true
+          [OpenStruct.new( :name => 'default', :fingerprint => 'AA:BB:CC:DD:EE:FF', :type => 'ssh-rsa' )]
+        end
+        $?.stub(:exitstatus) { 255 }
+        Net::SSH::KeyFactory.stub(:load_public_key) { raise NoMethodError }
+
+        wizard.send(:upload_ssh_key).should be_false
+
+        output = last_output
+        output.should match("Your ssh public key at .* is invalid or unreadable\.")
+        @fallback_run.should be_true
+      end
 
-    it "should cause upload_ssh_key to catch NotImplementedError and return false" do
-      wizard = RerunWizardDriver.new
-      wizard.ssh_keys = wizard.get_mock_key_data
-      Net::SSH::KeyFactory.stub(:load_public_key) { raise NotImplementedError }
+      it "should cause upload_ssh_key to catch NotImplementedError and return false" do
+        wizard.ssh_keys = wizard.get_mock_key_data
+        Net::SSH::KeyFactory.stub(:load_public_key) { raise NotImplementedError }
 
-      wizard.send(:upload_ssh_key).should be_false
+        wizard.send(:upload_ssh_key).should be_false
 
-      output = $terminal.read
-      output.should match("Your ssh public key at .* is invalid or unreadable\.")
-    end
+        output = last_output
+        output.should match("Your ssh public key at .* is invalid or unreadable\.")
+      end
 
-    it "should match ssh key fallback fingerprint to net::ssh fingerprint" do
-      # we need to write to a live file system so ssh-keygen can find it
-      FakeFS.deactivate!
-      wizard = RerunWizardDriver.new
-      Dir.mktmpdir do |dir|
-        wizard.setup_mock_ssh_keys(dir)
-        pub_ssh = File.join dir, "id_rsa.pub"
-        fallback_fingerprint = wizard.send :ssh_keygen_fallback, pub_ssh
-        internal_fingerprint, short_name = wizard.get_key_fingerprint pub_ssh
-
-        fallback_fingerprint.should == internal_fingerprint
+      it "should match ssh key fallback fingerprint to net::ssh fingerprint" do
+        # we need to write to a live file system so ssh-keygen can find it
+        FakeFS.deactivate!
+        Dir.mktmpdir do |dir|
+          setup_mock_ssh_keys(dir)
+          pub_ssh = File.join dir, "id_rsa.pub"
+          fallback_fingerprint = wizard.send :ssh_keygen_fallback, pub_ssh
+          internal_fingerprint, short_name = wizard.get_key_fingerprint pub_ssh
+
+          fallback_fingerprint.should == internal_fingerprint
+        end
+        FakeFS.activate!
       end
-      FakeFS.activate!
-    end
-    
-    context "when REST Client gets ValidationException for #add_domain" do
-      it "prints the exception message" do
-        msg = "Resource conflict"
-        wizard = FirstRunWizardDriver.new
-        wizard.rest_client.stub(:add_domain) { raise RHC::Rest::ValidationException, msg }
-        $terminal.write_line "testnamespace" # try to add a namespace
-        $terminal.write_line '' # the above input will raise exception.
-                                # we now skip configuring namespace.
-        wizard.send(:ask_for_namespace)
-        output = $terminal.read
-        output.should match msg
+
+      context "with the first run wizard" do
+        let(:wizard){ FirstRunWizardDriver.new }
+
+        it "prints the exception message when a domain error occurs" do
+          msg = "Resource conflict"
+          wizard.rest_client.stub(:add_domain) { raise RHC::Rest::ValidationException, msg }
+          input_line "testnamespace" # try to add a namespace
+          input_line '' # the above input will raise exception.
+                                  # we now skip configuring namespace.
+          wizard.send(:ask_for_namespace)
+          output = last_output
+          output.should match msg
+        end
+
+        it "should update the key correctly" do
+          key_name = 'default'
+          key_data = wizard.get_mock_key_data
+          wizard.ssh_keys = key_data
+          wizard.stub(:get_preferred_key_name) { key_name }
+          wizard.stub(:ssh_key_triple_for_default_key) { pub_key.chomp.split }
+          wizard.stub(:fingerprint_for_default_key) { "" } # this value is irrelevant
+          wizard.rest_client.stub(:find_key) { key_data.detect { |k| k.name == key_name } }
+
+          wizard.send(:upload_ssh_key)
+          output = last_output
+          output.should match 'Updating'
+        end
+
+        it 'should pick a usable SSH key name' do
+          File.exists?('1').should be_false
+          key_name = 'default'
+          key_data = wizard.get_mock_key_data
+          Socket.stub(:gethostname) { key_name }
+          input_line("\n") # to accept default key name
+          wizard.ssh_keys = key_data
+          wizard.stub(:ssh_key_triple_for_default_key) { pub_key.chomp.split }
+          wizard.stub(:fingerprint_for_default_key) { "" } # this value is irrelevant
+          wizard.rest_client.stub(:add_key) { true }
+
+          wizard.send(:upload_ssh_key)
+          output = last_output
+          # since the clashing key name is short, we expect to present
+          # a key name with "1" attached to it.
+          output.should match "|" + key_name + "1" + "|"
+          File.exists?('1').should be_false
+        end
       end
     end
-    
-    it "should update the key correctly" do
-      key_name = 'default'
-      wizard = FirstRunWizardDriver.new
-      key_data = wizard.get_mock_key_data
-      wizard.ssh_keys = key_data
-      wizard.stub(:get_preferred_key_name) { key_name }
-      wizard.stub(:ssh_key_triple_for_default_key) { wizard.pub_key.chomp.split }
-      wizard.stub(:fingerprint_for_default_key) { "" } # this value is irrelevant
-      wizard.rest_client.stub(:find_key) { key_data.detect { |k| k.name == key_name } }
-      
-      wizard.send(:upload_ssh_key)
-      output = $terminal.read
-      output.should match 'Updating'
-    end
-    
-    it 'should pick a usable SSH key name' do
-      key_name = 'default'
-      wizard = FirstRunWizardDriver.new
-      key_data = wizard.get_mock_key_data
-      Socket.stub(:gethostname) { key_name }
-      $terminal.write_line("\n") # to accept default key name
-      wizard.ssh_keys = key_data
-      wizard.stub(:ssh_key_triple_for_default_key) { wizard.pub_key.chomp.split }
-      wizard.stub(:fingerprint_for_default_key) { "" } # this value is irrelevant
-      wizard.rest_client.stub(:add_key) { true }
-      
-      wizard.send(:upload_ssh_key)
-      output = $terminal.read
-      # since the clashing key name is short, we expect to present
-      # a key name with "1" attached to it.
-      output.should match "|" + key_name + "1" + "|"
-    end
   end
 
   module WizardDriver
 
-    attr_accessor :mock_user, :libra_server, :config_path, :ssh_dir, :rest_client
+    attr_accessor :mock_user, :rest_client
     def initialize(*args)
-      RHC::Config.home_dir = '/home/mock_user'
+      if args.empty?
+        args = [RHC::Config.new, Commander::Command::Options.new]
+        args[1].default(args[0].to_options)
+      end
       super *args
-      @ssh_dir = "#{RHC::Config.home_dir}/.ssh/"
-      @libra_server = 'fake.foo'
+      raise "No options" if options.nil?
       @mock_user = 'mock_user@foo.bar'
       @current_wizard_stage = nil
       @platform_windows = false
+      #self.stub(:openshift_server).and_return('fake.foo')
     end
 
     def run_next_stage
@@ -669,30 +520,21 @@ describe RHC::Wizard do
     end
 
     def setup_mock_config(rhlogin=@mock_user)
-      FileUtils.mkdir_p File.dirname(@config_path)
-      File.open(@config_path, "w") do |file|
+      FileUtils.mkdir_p File.dirname(RHC::Config.local_config_path)
+      File.open(RHC::Config.local_config_path, "w") do |file|
         file.puts <<EOF
 # Default user login
 default_rhlogin='#{rhlogin}'
 
 # Server API
-libra_server = '#{@libra_server}'
+libra_server = '#{openshift_server}'
 EOF
       end
 
       # reload config
-      @config.home_dir = '/home/mock_user'
-    end
-
-    def setup_mock_ssh(add_ssh_key=false)
-      FileUtils.mkdir_p @ssh_dir
-      if add_ssh_key
-        setup_mock_ssh_keys
-      end
-    end
-
-    def setup_mock_has_git(bool)
-      self.stub(:"has_git?") { bool }
+      @config = RHC::Config.initialize
+      RHC::Config.ssh_dir.should =~ /mock_user/
+      @config.ssh_dir.should =~ /mock_user/
     end
 
     def setup_mock_domain_and_applications(domain, apps = {})
@@ -701,7 +543,7 @@ EOF
       apps.each do |app, url|
         apps_ary.push OpenStruct.new(
           :name => app,
-          :app_url => url == :default ? "http://#{app}-#{domain}.#{@libra_server}/" : url,
+          :app_url => url == :default ? "http://#{app}-#{domain}.#{openshift_server}/" : url,
           :u => true
         )
       end
@@ -736,6 +578,12 @@ EOF
         self.type = type
         self.content = content
       end
+      def type
+        @table[:type]
+      end
+      def type=(type)
+        @table[:type] = type
+      end
     end
 
     def get_mock_key_data
@@ -747,68 +595,31 @@ EOF
       ]
     end
 
-    def priv_key
-      <<EOF
------BEGIN RSA PRIVATE KEY-----
-MIICWwIBAAKBgQDIXpBBs7g93z/5JqW5IJNJR8bG6DWhpL2vR2ROEfzGqDHLZ+Xb
-saS/Ogc3nZNSav3juHWdiBFIc0unPpLdwmXtcL3tjN52CJqPgU/W0q061fL/tk77
-fFqW2upluo0ZRZQdPc3vTI3tWWZcpyE2LPHHUOI3KN+lRqxgw0Y6z/3SfwIDAQAB
-AoGAbMC+xZp5TsPEokOywWeH6cdWgZF5wpF7Dw7Nx34F2AFkfYWYAgVKaSxizHHv
-i1VdFmOBGw7Gaq+BiXXyGwEvdpmgDoZDwvJrShZef5LwYnJ/NCqjZ8Xbb9z4VxCL
-pkqMFFpEeNQcIDLZRF8Z1prRQnOL+Z498P6d3G/UWkR5NXkCQQDsGlpJzJwAPpwr
-YZ98LgKT0n2WHeCrMQ9ZyJQl3Dz40qasQmIotB+mdIh87EFex7vvyiuzRC5rfcoX
-CBHEkQpVAkEA2UFNBKgI1v5+16K0/CXPakQ25AlGODDv2VXlHwRPOayUG/Tn2joj
-fj0T4/pu9AGhz0oVXFlz7iO8PEwFU+plgwJAKD2tmdp31ErXj0VKS34EDnHX2dgp
-zMPF3AWlynYpJjexFLcTx+A7bMF76d7SnXbpf0sz+4/pYYTFBvvnG1ulKQJACJsR
-lfGiCAIkvB3x1VsaEDeLhRTo9yjZF17TqJrfGIXBiCn3VSmgZku9EfbFllzKMA/b
-MMFKWlCIEEtimqRaSQJAPVA1E7AiEvfUv0kRT73tDf4p/BRJ7p2YwjxrGpDBQhG1
-YI+4NOhWtAG3Uips++8RhvmLjv8y+TNKU31J1EJmYA==
------END RSA PRIVATE KEY-----
-EOF
+    def config_path
+      config.path
     end
-
-    def pub_key
-      <<EOF
-ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDIXpBBs7g93z/5JqW5IJNJR8bG6DWhpL2vR2ROEfzGqDHLZ+XbsaS/Ogc3nZNSav3juHWdiBFIc0unPpLdwmXtcL3tjN52CJqPgU/W0q061fL/tk77fFqW2upluo0ZRZQdPc3vTI3tWWZcpyE2LPHHUOI3KN+lRqxgw0Y6z/3Sfw== OpenShift-Key
-EOF
-    end
-
-    def setup_mock_ssh_keys(dir=@ssh_dir)
-      private_key_file = File.join(dir, "id_rsa")
-      public_key_file = File.join(dir, "id_rsa.pub")
-      File.open(private_key_file, 'w') { |f| f.write priv_key }
-
-      File.open(public_key_file, 'w') { |f| f.write pub_key }
-    end
-
-    def config(local_conf_path)
-      conf = RHC::Config
-      conf.set_local_config(local_conf_path, false)
-      conf
+    def openshift_server
+      super
     end
+#    def config(local_conf_path=nil)
+#      @config.set_local_config(local_conf_path, false) if local_conf_path
+#      @config
+#    end
   end
 
   class FirstRunWizardDriver < RHC::Wizard
     include WizardDriver
-
-    def initialize
-      super config('/home/mock_user/.openshift/express.conf')
-    end
   end
 
   class RerunWizardDriver < RHC::RerunWizard
     include WizardDriver
-
-    def initialize
-      super config('/home/mock_user/.openshift/express.conf')
-    end
   end
 
   class SSHWizardDriver < RHC::SSHWizard
     include WizardDriver
 
     def initialize
-      super RestSpecHelper::MockRestClient.new
+      super RestSpecHelper::MockRestClient.new, RHC::Config.new, Commander::Command::Options.new
     end
   end
 end