rhc 1.6.8 → 1.7.8

data/spec/rhc/highline_extensions_spec.rb

@@ -0,0 +1,269 @@
+require 'spec_helper'
+
+class OutputTests < SimpleDelegator
+  def initialize(terminal)
+    super
+    @print_num = 0
+  end
+
+  [:say, :agree, :ask, :choose].each do |sym|
+    define_method(sym) do |*args, &block|
+      __getobj__.send(sym, *args, &block)
+    end
+  end
+
+  def next_print_num
+    @print_num += 1
+  end
+
+  def output
+    say "section #{next_print_num}"
+  end
+
+  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 }
+  end
+
+  def section_one_break
+    section { output }
+  end
+
+  def sections_equal_bottom_top
+    section(:bottom => 1) { output }
+    section(:top => 1) { output }
+  end
+
+  def sections_larger_bottom
+    section(:bottom => 2) { output }
+    section(:top => 1) { output }
+  end
+
+  def sections_larger_top
+    section(:bottom => 1) { output }
+    section(:top => 2) { output }
+  end
+
+  def sections_four_on_three_lines
+    section { output }
+    section(:top => 1) { output_no_breaks }
+    section(:bottom => 1) { output }
+    section(:top => 1) { output }
+  end
+
+  def outside_newline
+    section(:bottom => -1) { output }
+    say "\n"
+    section(:top => 1) { output }
+  end
+
+  def section_1_1
+    section(:top => 1, :bottom => 1) { say "section" }
+  end
+
+  def section_paragraph
+    paragraph { say "section" }
+  end
+
+  # call section without output to reset spacing to 0
+  def reset
+    __getobj__.instance_variable_set(:@margin, 0)
+  end
+end
+
+
+describe HighLine::Header do 
+  it("should join a header"){ described_class.new("ab cd", 0).to_a.should == ["ab cd", '-----'] }
+  it("should wrap a header"){ described_class.new("ab cd", 4).to_a.should == ["ab", "cd", '--'] }
+  it("should wrap an array header"){ described_class.new(["ab cd"], 4).to_a.should == ["ab", "cd", '--'] }
+  it("should combine an array header"){ described_class.new(["ab", "cd"], 5).to_a.should == ["ab cd", '-----'] }
+  it("should wrap on array header boundaries"){ described_class.new(["abcd", "e"], 5).to_a.should == ["abcd", "e", '----'] }
+  it("should indent an array header"){ described_class.new(["ab", "cd"], 4, ' ').to_a.should == ["ab", " cd", '---'] }
+  it("should indent after a wrap"){ described_class.new(["ab cd", "ef gh", "ij"], 4, ' ').to_a.should == ["ab", "cd", " ef", " gh", " ij", '---'] }
+end
+
+describe HighLineExtension do
+  subject{ MockHighLineTerminal.new }
+
+  it("default_max_width should depend on wrap"){ subject.wrap_at = nil; subject.default_max_width.should be_nil}
+  it("default_max_width should handle indentation"){ subject.wrap_at = 10; subject.indent{ subject.default_max_width.should == 10 - subject.indentation.length } }
+
+  it "should wrap the terminal" do
+    subject.wrap_at = 10
+    subject.say "Lorem ipsum dolor sit amet"
+    output = subject.read
+    output.should match "Lorem\nipsum\ndolor sit\namet\n"
+  end
+  it "should wrap the terminal" do
+    subject.wrap_at = 16
+    subject.say "Lorem ipsum dolor sit amet"
+    output = subject.read
+    output.should == "Lorem ipsum\ndolor sit amet\n"
+  end
+  it "should not wrap the terminal" do
+    subject.wrap_at = 50
+    subject.say "Lorem ipsum dolor sit amet"
+    output = subject.read
+    output.should == "Lorem ipsum dolor sit amet\n"
+  end
+  it "should wrap the terminal when using color codes" do
+    subject.wrap_at = 10
+    subject.say subject.color("Lorem ipsum", :red)
+    output = subject.read
+    output.should == "\e[31mLorem\e\[0m\n\e[31mipsum\e[0m\n"
+  end
+  it "should wrap the terminal with other escape characters" do
+    subject.wrap_at = 10
+    subject.say "Lorem ipsum dolor sit am\eet"
+    output = subject.read
+    output.should == "Lorem\nipsum\ndolor sit\nam\eet\n"
+  end
+  it "should wrap the terminal when words are smaller than wrap length" do
+    subject.wrap_at = 3
+    subject.say "Antidisestablishmentarianism"
+    output = subject.read
+    output.should == "Antidisestablishmentarianism\n"
+  end
+
+  it "should wrap a table based on a max width" do
+    subject.table([["abcd efgh", "1234 6789 a"]], :width => 9, :heading => 'Test').to_a.should == [
+      'Test',
+      '----',
+      "abcd 1234",
+      "efgh 6789",
+      "     a"
+    ]
+  end
+
+  it "should allocate columns fairly in a table" do
+    subject.table([["abcd", "12345 67890"]], :width => 10).to_a.should == [
+      "abcd 12345",
+      "     67890",
+    ]
+  end
+
+  it "should not wrap without a width" do
+    subject.table([["abcd", "12345 67890"]]).to_a.should == [
+      "abcd 12345 67890",
+    ]
+  end
+  it "should implement each_line on the table" do
+    subject.table([["abcd", "12345 67890"]]).each_line.next.should == "abcd 12345 67890"
+  end
+
+  it "should display headers" do
+    subject.table([["abcd", "12345 67890"]], :header => ['abcdef', '123'], :width => 12).to_a.should == [
+      'abcdef 123',
+      '------ -----',
+      "abcd   12345",
+      "       67890",
+    ]
+  end
+
+  it "should add a header to a table" do
+    subject.table([["abcd efgh", "1234 6789 a"]], :width => 9, :heading => "Alongtextstring").to_a.should == [
+      "Alongtext",
+      "string",
+      "---------",
+      "abcd 1234",
+      "efgh 6789",
+      "     a"
+    ]
+  end
+
+  it "should indent a table" do
+    subject.table([["abcd efgh", "1234 6789 a"]], :indent => ' ', :width => 10).to_a.should == [
+      " abcd 1234",
+      " efgh 6789",
+      "      a"
+    ]
+  end
+
+  it "should not wrap table when not enough minimum width" do
+    subject.table([["ab cd", "12 34"]], :width => 4).to_a.should == [
+      "ab cd 12 34", 
+    ]
+  end
+
+  it "should not wrap table cells that are too wide based on a max width" do
+    subject.table([["abcdefgh", "1234567890"]], :width => 8).to_a.should == [
+      "abcdefgh 1234567890",
+    ]
+  end
+
+  it "should force wrap a table based on columns" do
+    subject.table([["ab cd", "123"]], :width => [6, 2]).to_a.should == [
+      "ab 123",
+      "cd",
+    ]
+  end
+
+  context "sections" do
+    let(:tests) { OutputTests.new(subject) }
+
+    it "should print out a paragraph with open endline on the same line" do
+      tests.section_same_line
+      subject.read.should == "section 1 word\n"
+    end
+
+    it "should print out a section without any line breaks" do
+      tests.section_no_breaks
+      subject.read.should == "section 1 \n"
+    end
+
+    it "should print out a section with trailing line break" do
+      tests.section_one_break
+      subject.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
+      subject.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
+      subject.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
+      subject.read.should == "section 1\n\n\nsection 2\n"
+    end
+
+    it "should print out 4 sections and not collapse open sections" do
+      tests.sections_four_on_three_lines
+      subject.read.should == "section 1\n\nsection 2 \nsection 3\n\nsection 4\n"
+    end
+
+    it "should show the equivalence of paragaph to section(:top => 1, :bottom => 1)" do
+      tests.section_1_1
+      section_1_1 = tests.read
+      
+      tests = OutputTests.new(MockHighLineTerminal.new)
+
+      tests.section_paragraph
+      paragraph = tests.read
+
+      section_1_1.should == paragraph
+    end
+    it "should combine sections" do
+      tests.section_1_1
+      tests.section_paragraph
+
+      subject.read.should == "section\n\nsection\n"
+    end
+
+    it "should not collapse explicit newline sections" do
+      tests.outside_newline
+      subject.read.should == "section 1\n\n\nsection 2\n"
+    end
+  end
+end

data/spec/rhc/rest_application_spec.rb

@@ -7,13 +7,14 @@ module RHC
     describe Application do
       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_aliases) { ['alias1','alias2'] }
       let (:app_obj) {
         args = {
           'domain_id'       => 'mock_domain',
           'name'            => 'mock_app',
           'creation_time'   => Time.now.to_s,
           'uuid'            => 1234,
-          'aliases'         => ['alias1','alias2'],
+          'aliases'         => app_aliases,
           'server_identity' => mock_uri,
           'links'           => app_links
         }
@@ -65,6 +66,32 @@ module RHC
         end
       end
 
+      context "#aliases" do
+        context "when the server returns an array of strings" do
+          it{ app_obj.aliases.first.should be_an_instance_of RHC::Rest::Alias }
+          it("converts to an object"){ app_obj.aliases.map(&:id).should == app_aliases }
+        end
+
+        context "when the server returns an object" do
+          let(:app_aliases){ [{'id' => 'alias1'}, {'id' => 'alias2'}] }
+          it{ app_obj.aliases.first.should be_an_instance_of RHC::Rest::Alias }
+          it{ app_obj.aliases.map(&:id).should == ['alias1', 'alias2'] }
+        end
+
+        context "when the server doesn't return aliases" do
+          let(:app_aliases){ nil }
+          context "when the client supports LIST_ALIASES" do
+            before{ stub_api_request(:any, app_links['LIST_ALIASES']['relative']).to_return(mock_alias_response(2)) }
+            it{ app_obj.aliases.first.should be_an_instance_of RHC::Rest::Alias }
+            it{ app_obj.aliases.map(&:id).should == ['www.alias0.com', 'www.alias1.com'] }
+          end
+          context "when the client doesn't support LIST_ALIASES" do
+            before{ app_links['LIST_ALIASES'] = nil }
+            it{ app_obj.aliases.should == [] }
+          end
+        end
+      end
+
       context "#cartridges" do
         let(:num_carts){ 0 }
         before(:each) do

data/spec/rhc/rest_client_spec.rb

@@ -2,7 +2,7 @@ require 'base64'
 require 'spec_helper'
 require 'stringio'
 require 'rest_spec_helper'
-require 'rhc/rest/client'
+require 'rhc/rest'
 
 # This object is used in a few cases where we need to inspect
 # the logged output.
@@ -22,24 +22,24 @@ module RHC
   module Rest
     describe Client do
 
+      after{ ENV['http_proxy'] = nil }
+      after{ ENV['HTTP_PROXY'] = nil }
+
       it 'should set the proxy protocol if it is missing' do
         ENV['http_proxy'] = 'foo.bar.com:8081'
-        load 'rhc/rest/client.rb'
-
+        RHC::Rest::Client.new
         ENV['http_proxy'].should == 'http://foo.bar.com:8081'
       end
 
       it 'should not alter the proxy protocol if it is present' do
         ENV['http_proxy'] = 'http://foo.bar.com:8081'
-        load 'rhc/rest/client.rb'
-
+        RHC::Rest::Client.new
         ENV['http_proxy'].should == 'http://foo.bar.com:8081'
       end
 
       it 'should not affect the proxy protocol if nil' do
         ENV['http_proxy'] = nil
-        load 'rhc/rest/client.rb'
-
+        RHC::Rest::Client.new
         ENV['http_proxy'].should be_nil
       end
 
@@ -80,13 +80,13 @@ module RHC
         context "against an endpoint that won't connect" do
           let(:endpoint){ mock_href('api_error') }
           it "raises an error message" do
-            expect{ client.api }.should raise_error
+            expect{ client.api }.to raise_error
           end
         end
         context "against an endpoint that has a generic error" do
           let(:endpoint){ mock_href('other_error') }
           it "raises a generic error for any other error condition" do
-            expect{ client.api }.should raise_error(RHC::Rest::ConnectionException, "An unexpected error occured: Other Error")
+            expect{ client.api }.to raise_error(RHC::Rest::ConnectionException, "An unexpected error occured: Other Error")
           end
         end
       end
@@ -227,13 +227,13 @@ module RHC
           end
           it "returns a domain object for matching domain IDs" do
             match = nil
-            expect { match = client.find_domain('mock_domain_0') }.should_not raise_error
+            expect { match = client.find_domain('mock_domain_0') }.to_not raise_error
 
             match.id.should == 'mock_domain_0'
             match.class.should == RHC::Rest::Domain
           end
           it "raise an error when no matching domain IDs can be found" do
-            expect { client.find_domain('mock_domain_2') }.should raise_error(RHC::Rest::DomainNotFoundException)
+            expect { client.find_domain('mock_domain_2') }.to raise_error(RHC::Rest::DomainNotFoundException)
           end
         end
 
@@ -275,16 +275,16 @@ module RHC
                 mock_response_links(mock_app_links(mock_domain, mock_app))
           end
           it "Raises an exception when no matching applications can be found" do
-            expect { client.find_application(mock_domain, missing) }.should raise_error(RHC::Rest::ApplicationNotFoundException)
+            expect { client.find_application(mock_domain, missing) }.to raise_error(RHC::Rest::ApplicationNotFoundException)
           end
           it "Raises an exception when no matching domain can be found" do
-            expect { client.find_application(missing, mock_app) }.should raise_error(RHC::Rest::DomainNotFoundException)
+            expect { client.find_application(missing, mock_app) }.to raise_error(RHC::Rest::DomainNotFoundException)
           end
         end
 
         describe RHC::Rest::Cartridge do
           subject do
-            described_class.new({
+            RHC::Rest::Cartridge.new({
               :name => 'foo',
               :links => mock_response_links([
                 ['GET', 'broker/rest/cartridge', 'get']
@@ -444,7 +444,7 @@ module RHC
           end
           it "returns a list of key objects for matching keys" do
             key = nil
-            expect { key = client.find_key('mock_key_0') }.should_not raise_error
+            expect { key = client.find_key('mock_key_0') }.to_not raise_error
 
             key.class.should   == RHC::Rest::Key
             key.name.should    == 'mock_key_0'
@@ -454,7 +454,7 @@ module RHC
               mock_response_links(mock_key_links('mock_key_0'))
           end
           it "raise an error when no matching keys can be found" do
-            expect { client.find_key('no_match') }.should raise_error(RHC::KeyNotFoundException)
+            expect { client.find_key('no_match') }.to raise_error(RHC::KeyNotFoundException)
           end
         end
 
@@ -521,12 +521,11 @@ module RHC
           end
 
           it "should delete keys" do
-            expect { client.delete_key('mock_key_0') }.should be_true
+            expect { client.delete_key('mock_key_0') }.to be_true
           end
 
           it 'raises an error if nonexistent key is requested' do
-            expect { client.find_key('no_match') }.
-              should raise_error(RHC::KeyNotFoundException)
+            expect { client.find_key('no_match') }.to raise_error(RHC::KeyNotFoundException)
           end
         end
 
@@ -589,11 +588,11 @@ module RHC
       describe "#supports_sessions?" do
         before{ subject.should_receive(:api).at_least(2).times.and_return(stub) }
         context "with ADD_AUTHORIZATION link" do
-          before{ subject.api.should_receive(:supports?).twice.with('ADD_AUTHORIZATION').and_return(true) }
+          before{ subject.api.should_receive(:supports?).with('ADD_AUTHORIZATION').and_return(true) }
           its(:supports_sessions?){ should be_true }
         end
         context "without ADD_AUTHORIZATION link" do
-          before{ subject.api.should_receive(:supports?).twice.with('ADD_AUTHORIZATION').and_return(false) }
+          before{ subject.api.should_receive(:supports?).with('ADD_AUTHORIZATION').and_return(false) }
           its(:supports_sessions?){ should be_false }
         end
       end