rhc 1.2.7 → 1.3.8

data/spec/rhc/context_spec.rb

@@ -3,6 +3,8 @@ require 'rhc/commands/base'
 require 'rhc/exceptions'
 
 describe RHC::Commands::Base do
+  before{ base_config }
+
   context 'when statically defined with context' do
     subject do
       Kernel.module_eval do

data/spec/rhc/helpers_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 require 'rhc/helpers'
-require 'rhc/ssh_key_helpers'
+require 'rhc/ssh_helpers'
 require 'rhc/cartridge_helpers'
+require 'rhc/git_helpers'
 require 'rhc/core_ext'
 require 'highline/import'
 require 'rhc/config'
@@ -11,23 +12,32 @@ require 'date'
 describe RHC::Helpers do
   before(:each) do
     mock_terminal
-    RHC::Config.set_defaults
-    @tests = HelperTests.new
+    user_config
   end
 
   subject do
     Class.new(Object) do
       include RHC::Helpers
+      include RHC::SSHHelpers
 
       def config
-        @config ||= RHC::Config
+        @config ||= RHC::Config.new
+      end
+      def options
+        @options ||= OpenStruct.new([:server])
       end
     end.new
   end
+  let(:tests) { OutputTests.new }
 
   its(:openshift_server) { should == 'openshift.redhat.com' }
   its(:openshift_url) { should == 'https://openshift.redhat.com' }
 
+  it("should display slashes"){ subject.system_path('foo/bar').should == 'foo/bar' }
+  context "on windows" do
+    it("should display backslashes"){ with_constants({:ALT_SEPARATOR => '\\'}, File) { subject.system_path('foo/bar').should == 'foo\\bar' } }
+    it("should handle drives"){ with_constants({:ALT_SEPARATOR => '\\'}, File) { subject.system_path('C:/foo/bar').should == 'C:\\foo\\bar' } }
+  end
 
   it("should pluralize many") { subject.pluralize(3, 'fish').should == '3 fishs' }
   it("should not pluralize one") { subject.pluralize(1, 'fish').should == '1 fish' }
@@ -35,10 +45,10 @@ describe RHC::Helpers do
   it("should decode json"){ subject.decode_json("{\"a\" : 1}").should == {'a' => 1} }
 
   it("should output green on success") do
-    capture{ subject.success 'this is green' }.should == "\e[32mthis is green\e[0m"
+    capture{ subject.success 'this is green' }.should == "\e[32mthis is green\e[0m\n"
   end
   it("should output yellow on warn") do
-    capture{ subject.success 'this is yellow' }.should == "\e[32mthis is yellow\e[0m"
+    capture{ subject.success 'this is yellow' }.should == "\e[32mthis is yellow\e[0m\n"
   end
   it("should return true on success"){ subject.success('anything').should be_true }
   it("should return true on success"){ subject.warn('anything').should be_true }
@@ -49,8 +59,6 @@ describe RHC::Helpers do
     end.should == ['10 2','3  40']
   end
 
-  it("should generate table rows"){ subject.send(:make_table, [1,2]).should == [1,2] }
-  it("should generate a table"){ subject.send(:make_table, 1).should == [1] }
   it("should output a table") do 
     subject.send(:display_no_info, 'test').should == ['This test has no information to show']
   end
@@ -63,22 +71,48 @@ describe RHC::Helpers do
   end
 
   context 'using the current time' do
-    let(:now){ Time.now }
+    let(:date){ Time.local(2008,1,2,1,1,0) }
+    let(:today){ Date.new(2008,1,2) }
+    before{ Date.stub(:today).and_return(today) }
+
     let(:rfc3339){ '%Y-%m-%dT%H:%M:%S%z' }
     it("should output the time for a date that is today") do
-      subject.date(now.strftime(rfc3339)).should =~ /^[0-9]/
+      subject.date(date.strftime(rfc3339)).should =~ /^[0-9]/
+    end
+    it("should exclude the year for a date that is this year") do
+      subject.date(date.strftime(rfc3339)).should_not match(date.year.to_s)
     end
     it("should output the year for a date that is not this year") do
-      older = now - 1*365*24*60
-      subject.date(older.strftime(rfc3339)).should =~ /^[A-Z]/
+      older = Date.today - 1*365
+      subject.date(older.strftime(rfc3339)).should match(older.year.to_s)
+    end
+    it("should handle invalid input") do
+      subject.date('Unknown date').should == 'Unknown date'
+    end
+
+    context 'when the year is different' do
+      let(:today){ Date.new(2007,1,2) }
+      it{ subject.date(date.strftime(rfc3339)).should match(date.year.to_s) }
+    end
+
+    context 'when the year of the day is different' do
+      let(:today){ Date.new(2008,1,1) }
+      it{ subject.date(date.strftime(rfc3339)).should_not match(date.year.to_s) }
     end
   end
 
   context 'with LIBRA_SERVER environment variable' do
     before do
       ENV['LIBRA_SERVER'] = 'test.com'
-      # need to reinit config to pick up env var
-      RHC::Config.initialize
+      user_config
+    end
+    its(:openshift_server) { should == 'test.com' }
+    its(:openshift_url) { should == 'https://test.com' }
+    after { ENV['LIBRA_SERVER'] = nil }
+  end
+  context 'with --server environment variable' do
+    before do
+      subject.options.server = "test.com"
     end
     its(:openshift_server) { should == 'test.com' }
     its(:openshift_url) { should == 'https://test.com' }
@@ -86,63 +120,188 @@ describe RHC::Helpers do
   end
 
   context "without RHC::Config" do
-    subject do 
+    subject do
       Class.new(Object){ include RHC::Helpers }.new
     end
 
     it("should raise on config"){ expect{ subject.config }.should raise_error }
   end
 
+  context "with a bad timeout value" do
+    context "on the command line" do
+      let(:arguments){ ['help', '--timeout=string'] }
+      it{ expect{ run }.to exit_with_code(1) }
+      it{ run_output.should match("invalid argument: --timeout=string") }
+    end
+    context "via the config" do
+      before{ base_config{ |c, d| d.add 'timeout', 'string' } }
+      let(:arguments){ ['help'] }
+      it{ expect{ run }.to exit_with_code(1) }
+      it{ run_output.should match(/The configuration file.*invalid setting: invalid value for Integer/) }
+    end
+  end
+  context "with a valid client cert file" do
+    let(:arguments){ ['help', '--ssl-client-cert-file=spec/keys/example.pem'] }
+    it{ expect{ run }.to exit_with_code(0) }
+  end
+
+  context "with a missing client cert file" do
+    context "on the command line" do
+      let(:arguments){ ['help', '--ssl-client-cert-file=not_a_file'] }
+      it{ expect{ run }.to exit_with_code(1) }
+      it{ run_output.should match("The certificate 'not_a_file' cannot be loaded: No such") }
+    end
+    context "via the config" do
+      before{ base_config{ |c, d| d.add 'ssl_client_cert_file', 'not_a_file' } }
+      let(:arguments){ ['help'] }
+      it{ expect{ run }.to exit_with_code(1) }
+      it{ run_output.should match("The certificate 'not_a_file' cannot be loaded: No such") }
+    end
+  end
+
+  context 'with a valid --ssl-version' do
+    let(:arguments){ ['help', '--ssl-version=sslv3'] }
+
+    context 'on an older version of HTTPClient' do
+      before{ HTTPClient::SSLConfig.should_receive(:method_defined?).any_number_of_times.with(:ssl_version).and_return(false) }
+      it('should print an error') { run_output.should =~ /You are using an older version of the httpclient.*--ssl-version/ }
+      it('should error out') { expect{ run }.to exit_with_code(1) }
+    end
+    context 'a newer version of HTTPClient' do
+      before{ HTTPClient::SSLConfig.should_receive(:method_defined?).any_number_of_times.with(:ssl_version).and_return(true) }
+      it('should not print an error') { run_output.should_not =~ /You are using an older version of the httpclient.*--ssl-version/ }
+      it('should error out') { expect{ run }.to exit_with_code(0) }
+    end
+  end
+
+  context "with an invalid SSLVersion" do
+    context "on the command line" do
+      let(:arguments){ ['help', '--ssl-version=ssl'] }
+      it{ expect{ run }.to exit_with_code(1) }
+      it{ run_output.should match("The provided SSL version 'ssl' is not valid. Supported values: ") }
+    end
+    context "via the config" do
+      before{ base_config{ |c, d| d.add 'ssl_version', 'ssl' } }
+      let(:arguments){ ['help'] }
+      it{ expect{ run }.to exit_with_code(1) }
+      it{ run_output.should match("The provided SSL version 'ssl' is not valid. Supported values: ") }
+    end
+  end
+
+  context "with an valid ssl CA file" do
+    let(:arguments){ ['help', '--ssl-ca-file=spec/keys/example.pem'] }
+    it{ expect{ run }.to exit_with_code(0) }
+  end
+
+  context "with an invalid ssl CA file" do
+    let(:arguments){ ['help', '--ssl-ca-file=not_a_file'] }
+    it{ expect{ run }.to exit_with_code(1) }
+    it{ run_output.should match("The certificate 'not_a_file' cannot be loaded: No such file or directory ") }
+  end
+
   context "Formatter" do
+    before{ tests.reset }
+
+    it "should print out a paragraph with open endline on the same line" do
+      tests.section_same_line
+      $terminal.read.should == "section 1 word\n"
+    end
+
     it "should print out a section without any line breaks" do
-      @tests.section_no_breaks
-      $terminal.read.should == "section 1 "
+      tests.section_no_breaks
+      $terminal.read.should == "section 1 \n"
     end
 
     it "should print out a section with trailing line break" do
-      @tests.section_one_break
+      tests.section_one_break
       $terminal.read.should == "section 1\n"
     end
 
     it "should print out 2 sections with matching bottom and top margins generating one space between" do
-      @tests.sections_equal_bottom_top
+      tests.sections_equal_bottom_top
       $terminal.read.should == "section 1\n\nsection 2\n"
     end
 
     it "should print out 2 sections with larger bottom margin generating two spaces between" do
-      @tests.sections_larger_bottom
+      tests.sections_larger_bottom
       $terminal.read.should == "section 1\n\n\nsection 2\n"
     end
 
     it "should print out 2 sections with larger top margin generating two spaces between" do
-      @tests.sections_larger_top
+      tests.sections_larger_top
       $terminal.read.should == "section 1\n\n\nsection 2\n"
     end
 
-    it "should print out 4 sections with the middle two on the same line and a space between the lines" do
-      @tests.sections_four_on_three_lines
-      $terminal.read.should == "section 1\n\nsection 2 section 3\n\nsection 4\n"
+    it "should print out 4 sections and not collapse open sections" do
+      tests.sections_four_on_three_lines
+      $terminal.read.should == "section 1\n\nsection 2 \nsection 3\n\nsection 4\n"
     end
 
     it "should show the equivilance of paragaph to section(:top => 1, :bottom => 1)" do
-      @tests.section_1_1
+      tests.section_1_1
       section_1_1 = $terminal.read
-      @tests.reset
-      @tests.section_paragraph
+      tests.reset
+      tests.section_paragraph
       paragraph = $terminal.read
 
       section_1_1.should == paragraph
 
-      @tests.reset
-      @tests.section_1_1
-      @tests.section_paragraph
+      tests.reset
+      tests.section_1_1
+      tests.section_paragraph
 
-      $terminal.read.should == "\nsection\n\nsection\n\n"
+      $terminal.read.should == "section\n\nsection\n"
     end
 
-    it "should show two line with one space between even though an outside newline was printed" do
-      @tests.outside_newline
-      $terminal.read.should == "section 1\n\nsection 2\n"
+    it "should not collapse explicit newline sections" do
+      tests.outside_newline
+      $terminal.read.should == "section 1\n\n\nsection 2\n"
+    end
+  end
+
+  context "Git Helpers" do
+    subject{ Class.new(Object){ include RHC::Helpers; include RHC::GitHelpers; def debug?; false; end }.new }
+    before{ subject.stub(:git_version){ raise "Fake Exception" } }
+    its(:has_git?) { should be_false }
+
+    context "git clone repo" do
+      let(:stdout){ 'fake git clone' }
+      let(:exit_status){ 0 }
+      let!(:spawn) do
+        out, err = stdout, stderr
+        Open4.should_receive(:spawn).and_return(exit_status) do |cmd, opts|
+          opts['stdout'] << out if out
+          opts['stderr'] << err if err
+          exit_status
+        end
+        true
+      end
+
+      it { capture{ subject.git_clone_repo("url", "repo").should be_true } }
+      it { capture_all{ subject.git_clone_repo("url", "repo") }.should match("fake git clone") }
+
+      context "does not succeed" do
+        let(:stderr){ 'fatal: error' }
+        let(:exit_status){ 1 }
+
+        it { capture{ expect{ subject.git_clone_repo("url", "repo") }.should raise_error(RHC::GitException) } }
+        it { capture_all{ subject.git_clone_repo("url", "repo") rescue nil }.should match("fake git clone") }
+        it { capture_all{ subject.git_clone_repo("url", "repo") rescue nil }.should match("fatal: error") }
+      end
+
+      context "directory is missing" do
+        let(:stderr){ "fatal: destination path 'foo' already exists and is not an empty directory." }
+        let(:exit_status){ 1 }
+
+        it { capture{ expect{ subject.git_clone_repo("url", "repo") }.should raise_error(RHC::GitDirectoryExists) } }
+      end
+
+      context "permission denied" do
+        let(:stderr){ "Permission denied (publickey,gssapi-mic)." }
+        let(:exit_status){ 1 }
+
+        it { capture{ expect{ subject.git_clone_repo("url", "repo") }.should raise_error(RHC::GitPermissionDenied) } }
+      end
     end
   end
 
@@ -150,15 +309,21 @@ describe RHC::Helpers do
     it "should generate an ssh key then return nil when it tries to create another" do
       FakeFS do
         FakeFS::FileSystem.clear
-        @tests.generate_ssh_key_ruby.should match("\.ssh/id_rsa\.pub")
-        @tests.generate_ssh_key_ruby == nil
+        subject.generate_ssh_key_ruby.should match("\.ssh/id_rsa\.pub")
+        subject.generate_ssh_key_ruby == nil
       end
     end
+
+    it "should print an error when finger print fails" do
+      Net::SSH::KeyFactory.should_receive(:load_public_key).with('1').and_raise(Net::SSH::Exception.new("An error"))
+      subject.should_receive(:error).with('An error')
+      subject.fingerprint_for_local_key('1').should be_nil
+    end
   end
 
-  class HelperTests
+  class OutputTests
     include RHC::Helpers
-    include RHC::SSHKeyHelpers
+    include RHC::SSHHelpers
 
     def initialize
       @print_num = 0
@@ -180,6 +345,10 @@ describe RHC::Helpers do
     def output_no_breaks
       say "section #{next_print_num} "
     end
+    
+    def section_same_line
+      section { output_no_breaks; say 'word' }
+    end
 
     def section_no_breaks
       section { output_no_breaks }
@@ -227,11 +396,21 @@ describe RHC::Helpers do
 
     # call section without output to reset spacing to 0
     def reset
-      section {}
+      RHC::Helpers.send(:class_variable_set, :@@margin, nil)
     end
   end
 end
 
+describe RHC::Helpers::StringTee do
+  let(:other){ StringIO.new }
+  subject{ RHC::Helpers::StringTee.new(other) }
+  context "It should copy output" do
+    before{ subject << 'foo' }
+    its(:string) { should == 'foo' }
+    it("should tee to other") { other.string.should == 'foo' }
+  end
+end
+
 describe Object do
   context 'present?' do
     specify('nil') { nil.present?.should be_false }
@@ -241,6 +420,14 @@ describe Object do
     specify('empty string') { ''.present?.should be_false }
   end
 
+  context 'presence' do
+    specify('nil') { nil.presence.should be_nil }
+    specify('empty array') { [].presence.should be_nil }
+    specify('array') { [1].presence.should == [1] }
+    specify('string') { 'a'.presence.should == 'a' }
+    specify('empty string') { ''.presence.should be_nil }
+  end
+
   context 'blank?' do
     specify('nil') { nil.blank?.should be_true }
     specify('empty array') { [].blank?.should be_true }
@@ -299,7 +486,6 @@ end
 describe RHC::CartridgeHelpers do
   before(:each) do
     mock_terminal
-    @tests = HelperTests.new
   end
 
   subject do
@@ -315,13 +501,23 @@ describe RHC::CartridgeHelpers do
   describe '#find_cartridge' do
     let(:cartridges){ [] }
     let(:find_cartridges){ [] }
-    let(:rest_obj) do
-      Object.new.tap do |o|
-        o.stub(:find_cartridges).and_return(find_cartridges)
-        o.stub(:cartridges).and_return(cartridges)
+    context "with a generic object" do
+      let(:rest_obj) do
+        Object.new.tap do |o|
+          o.stub(:find_cartridges).and_return(find_cartridges)
+          o.stub(:cartridges).and_return(cartridges)
+        end
       end
+      it { expect{ subject.find_cartridge(rest_obj, 'foo') }.should raise_error(RHC::CartridgeNotFoundException, 'Cartridge \'foo\' is not a valid cartridge name.') }
+    end
+    context "with an Application" do
+      let(:rest_obj) do
+        RHC::Rest::Application.new('name' => 'my_app').tap do |o|
+          o.stub(:find_cartridges).and_return(find_cartridges)
+          o.stub(:cartridges).and_return(cartridges)
+        end
+      end
+      it { expect{ subject.find_cartridge(rest_obj, 'foo') }.should raise_error(RHC::CartridgeNotFoundException, 'Cartridge \'foo\' cannot be found in application \'my_app\'.') }
     end
-
-    it { expect{ subject.find_cartridge(rest_obj, 'foo') }.should raise_error(RHC::CartridgeNotFoundException, 'Invalid cartridge specified: \'foo\'. No cartridges have been added to this app.') }
   end
 end

data/spec/rhc/rest_application_spec.rb

@@ -5,22 +5,20 @@ require 'base64'
 module RHC
   module Rest
     describe Application do
-      # make sure auth is set up for the Application object since we are not
-      # calling it from RHC::Rest::Client
-      credentials = Base64.strict_encode64("#{mock_user}:#{mock_pass}")
-      @@headers["Authorization"] = "Basic #{credentials}"
-      @@headers["User-Agent"] = RHC::Helpers.user_agent
-
+      let (:client) { RHC::Rest::Client.new('test.domain.com', 'test_user', 'test pass') }
       let (:app_links) { mock_response_links(mock_app_links('mock_domain','mock_app')) }
       let (:app_obj) {
-        RHC::Rest::Application.new({ 'domain_id'       => 'mock_domain',
-                                     'name'            => 'mock_app',
-                                     'creation_time'   => Time.now.to_s,
-                                     'uuid'            => 1234,
-                                     'aliases'         => ['alias1','alias2'],
-                                     'server_identity' => mock_uri,
-                                     'links'           => app_links
-                                   })
+        args = {
+          'domain_id'       => 'mock_domain',
+          'name'            => 'mock_app',
+          'creation_time'   => Time.now.to_s,
+          'uuid'            => 1234,
+          'aliases'         => ['alias1','alias2'],
+          'server_identity' => mock_uri,
+          'links'           => app_links
+        }
+        args.merge!(attributes) if defined?(attributes)
+        RHC::Rest::Application.new(args, client)
       }
       context "#new" do
         it "returns an application object" do
@@ -44,25 +42,41 @@ module RHC
       end
 
       context "#cartridges" do
+        let(:num_carts){ 0 }
         before(:each) do
           stub_api_request(:any, app_links['LIST_CARTRIDGES']['relative']).
-            to_return(mock_cartridge_response(2)).
-            to_return(mock_cartridge_response(0))
+            to_return(mock_cartridge_response(num_carts))
         end
-        it "returns a list of all cartridges in the current application" do
-          app   = app_obj
-          carts = app.cartridges
-          carts.length.should equal(2)
-          (0..1).each do |idx|
-            carts[idx].should be_an_instance_of RHC::Rest::Cartridge
-            carts[idx].name.should == "mock_cart_#{idx}"
+        context "with carts" do
+          let(:num_carts){ 2 }
+          it "returns a list of all cartridges in the current application" do
+            app   = app_obj
+            carts = app.cartridges
+            carts.length.should == 2
+            (0..1).each do |idx|
+              carts[idx].should be_an_instance_of RHC::Rest::Cartridge
+              carts[idx].name.should == "mock_cart_#{idx}"
+            end
           end
         end
-        it "returns an empty list if the current app has no cartridges" do
-          app   = app_obj
-          carts = app.cartridges # Disregard the first request;
-          carts = app.cartridges # 2nd request simulates empty response.
-          carts.length.should equal(0)
+        context "without carts" do
+          it "returns an empty list" do
+            app   = app_obj
+            carts = app.cartridges
+            carts.length.should == 0
+          end
+        end
+        context "with carts included in initial reponse" do
+          let(:attributes){ {:cartridges => RHC::Json.decode(mock_cartridge_response(2)[:body])['data'] }}
+          it "returns a list of all cartridges in the current application" do
+            app   = app_obj
+            carts = app.cartridges
+            carts.length.should == 2
+            (0..1).each do |idx|
+              carts[idx].should be_an_instance_of RHC::Rest::Cartridge
+              carts[idx].name.should == "mock_cart_#{idx}"
+            end
+          end
         end
       end