startapp 0.1.6

data/spec/rhc/highline_extensions_spec.rb

@@ -0,0 +1,314 @@
+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 terminate an open line if wrapping occurs" do
+    subject.wrap_at = 10
+    subject.say "Foo "
+    subject.say "Lorem ipsum"
+    output = subject.read
+    output.should match "Foo \nLorem\nipsum\n"
+  end
+
+  it "should handle an empty table" do
+    subject.table([]).to_a.should == []
+  end
+
+  it "should handle a nested empty table" do
+    subject.table([[]]).to_a.should == []
+  end
+
+  it "should normalize variables" do
+    subject.table([
+        ["a", 5],
+        [nil, ['a', 'b']],
+      ]).to_a.should == [
+        "a 5",
+        "  a",
+        "  b",
+      ]
+  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
+
+  # FIXME: Ragged edges still left by the algorithm
+  # 104 total width, 1: 32/52, 2: 8/61, 113 total width
+  it "should handle when columns are evenly split" do
+    subject.table([
+      ["#{'a'*32} #{'b'*19}", "#{'c'*8} "*6+"d"*7]
+    ], :width => 104).to_a.should == [
+      "a"*32+" "+'b'*19+" "+Array.new(5, 'c'*8).join(' '),
+      ' '*53+"#{'c'*8} "+'d'*7
+    ]
+  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 give the header priority over width when color is involved" do
+    subject.table([["\e[31mabcd\e[0m", "1234567890"]], :header => ['abcdef', '123'], :width => 12).to_a.should == [
+      'abcdef 123',
+      '------ ----------',
+      "\e[31mabcd\e[0m   1234567890",
+    ]
+  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/json_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'rhc/json'
+
+describe RHC::Json do
+
+  context 'with simple decoded hash as a string' do
+    subject { RHC::Json.decode '{"abc":[123,-456.789e0],"def":[456,-456.789e0],"ghi":"ghj"}' }
+    its(:length) { should == 3 }
+    it('should contain key') { subject.has_key?("abc").should be_true  }
+    it('should contain key') { subject.has_key?("def").should be_true  }
+    it('should contain key') { subject.has_key?("ghi").should be_true  }
+    it('should not contain invalid key') { subject.has_key?("ghj").should be_false  }
+    it('should contain value for key') { subject.has_value?("ghj").should be_true  }
+    it('should contain array value') { subject["abc"].is_a?(Array).should be_true  }
+    it('should contain array with two elements') { subject["abc"].length.should == 2  }
+    it('should contain array with an integer') { subject["abc"][0].should == 123  }
+    it('should contain array with a float') { subject["abc"][1].should == -456.789e0 }
+  end
+
+  context 'with simple hash' do
+    subject { RHC::Json.encode({"key" => "value"}) }
+    it('should encode to proper json') { subject.should == '{"key":"value"}'  }
+    it('should encode and decode to the same hash') { RHC::Json.decode(subject).should == {"key" => "value"} }
+    it('should decode and encode to the same string') { RHC::Json.encode(RHC::Json.decode('{"x":"y"}')).should == '{"x":"y"}' }
+    it('should decode symbol keys') { RHC::Json.decode('{"key":"ok"}', {:symbolize_keys => true}).has_key?(:key).should be_true }
+    it('should decode symbol keys') { RHC::Json.decode('{"key":"ok"}', {:symbolize_keys => true})[:key].should == "ok" }
+    it('should encode symbol keys') { RHC::Json.encode({:key => "ok"}).should == '{"key":"ok"}' }
+  end
+
+end

data/spec/rhc/rest_application_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+require 'rest_spec_helper'
+require 'base64'
+
+module RHC
+  module Rest
+    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'         => app_aliases,
+          '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
+          app = app_obj
+          app.should be_an_instance_of RHC::Rest::Application
+          app.send(:links).length.should equal(app_links.length)
+        end
+      end
+
+      describe "#ssh_string" do
+        context "with valid url" do
+          subject{ described_class.new('ssh_url' => "ssh://foo@bar.com/path") }
+          its(:ssh_string){ should == "foo@bar.com" }
+        end
+        context "with bad url" do
+          subject{ described_class.new('ssh_url' => "ssh://") }
+          its(:ssh_string){ should == "ssh://" }
+        end
+      end
+
+      describe "#host" do
+        context "with bad url" do
+          subject{ described_class.new('app_url' => "http://") }
+          its(:app_url){ should == "http://" }
+          its(:host){ should be_nil }
+        end
+        context "with http url" do
+          subject{ described_class.new('app_url' => "http://bar.com/path") }
+          its(:app_url){ should == "http://bar.com/path" }
+          its(:host){ should == "bar.com" }
+        end
+      end
+
+      context "#add_cartridge" do
+        context "with a name" do
+          before{ stub_api_request(:any, app_links['ADD_CARTRIDGE']['relative'], false).with(:body => {:name => 'mock_cart_0'}.to_json).to_return(mock_cartridge_response) }
+          it "accepts a string" do
+            cart = app_obj.add_cartridge('mock_cart_0')
+            cart.should be_an_instance_of RHC::Rest::Cartridge
+            cart.name.should == 'mock_cart_0'
+          end
+          it "accepts an object" do
+            cart = app_obj.add_cartridge(double(:name => 'mock_cart_0', :url => nil))
+            cart.should be_an_instance_of RHC::Rest::Cartridge
+            cart.name.should == 'mock_cart_0'
+          end
+          it "accepts a hash" do
+            cart = app_obj.add_cartridge(:name => 'mock_cart_0')
+            cart.should be_an_instance_of RHC::Rest::Cartridge
+            cart.name.should == 'mock_cart_0'
+          end
+        end
+
+        context "with a URL cart" do
+          before{ stub_api_request(:any, app_links['ADD_CARTRIDGE']['relative'], false).with(:body => {:url => 'http://foo.com'}.to_json).to_return(mock_cartridge_response(1, true)) }
+          it "raises without a param" do
+            app_obj.should_receive(:has_param?).with('ADD_CARTRIDGE','url').and_return(false)
+            expect{ app_obj.add_cartridge({:url => 'http://foo.com'}) }.to raise_error(RHC::Rest::DownloadingCartridgesNotSupported)
+          end
+          it "accepts a hash" do
+            app_obj.should_receive(:has_param?).with('ADD_CARTRIDGE','url').and_return(true)
+            cart = app_obj.add_cartridge({:url => 'http://foo.com'})
+            cart.should be_an_instance_of RHC::Rest::Cartridge
+            cart.name.should == 'mock_cart_0'
+            cart.url.should == 'http://a.url/0'
+            cart.short_name.should == 'mock_cart_0'
+            cart.display_name.should == 'mock_cart_0'
+            cart.only_in_new?.should be_true
+            cart.only_in_existing?.should be_false
+          end
+          it "accepts an object" do
+            app_obj.should_receive(:has_param?).with('ADD_CARTRIDGE','url').and_return(true)
+            cart = app_obj.add_cartridge(double(:url => 'http://foo.com'))
+            cart.should be_an_instance_of RHC::Rest::Cartridge
+            cart.name.should == 'mock_cart_0'
+            cart.url.should == 'http://a.url/0'
+            cart.short_name.should == 'mock_cart_0'
+            cart.display_name.should == 'mock_cart_0'
+            cart.only_in_new?.should be_true
+            cart.only_in_existing?.should be_false
+          end
+        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'], false).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 do
+          stub_api_request(:any, app_links['LIST_CARTRIDGES']['relative'], false).
+            to_return(mock_cartridge_response(num_carts))
+        end
+        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
+        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
+
+      context "#gear_groups" do
+        before do
+          stub_api_request(:any, app_links['GET_GEAR_GROUPS']['relative'], false).
+            to_return(mock_gear_groups_response())
+        end
+        it "returns a list of all gear groups the current application" do
+          app   = app_obj
+          gear_groups = app.gear_groups
+          gear_groups.length.should equal(1)
+          gear_groups[0].should be_an_instance_of RHC::Rest::GearGroup
+        end
+      end
+
+      # These application control tests are subtle; the key lies in making sure the
+      # webmock specifies the expected body that is sent in the request.
+      # This is currently of the form "event=foo"
+      shared_examples_for "a control method" do
+        before do
+          @control_method = control_data[:method]
+          @control_call   = [@control_method]
+          if control_data.has_key?(:arg)
+            @control_call << control_data[:arg]
+          end
+          @control_event  = control_data.has_key?(:event)   ? control_data[:event]       : @control_method.to_s
+          @control_link   = control_data.has_key?(:link)    ? control_data[:link].upcase : @control_method.to_s.upcase
+          @control_output = control_data.has_key?(:result)  ? control_data[:result]      : @control_event
+          @with_payload   = control_data.has_key?(:payload) ? control_data[:payload]     : true
+          if @with_payload
+            stub_api_request(:any, app_links[@control_link]['relative'], false).
+              with(:body => { 'event' => @control_event }). # This is the critical part
+              to_return({ :body => { :data => @control_event }.to_json, :status => 200 })
+          else
+            stub_api_request(:any, app_links[@control_link]['relative'], false).
+              to_return({ :body => { :data => @control_event }.to_json, :status => 200 })
+          end
+        end
+        it "sends the control request to the server" do
+          app = app_obj
+          expect { app.send(*@control_call)  }.to_not raise_error
+          app.send(*@control_call).should == @control_output
+        end
+      end
+
+      context "#start" do
+        let(:control_data) { { :method => :start } }
+        it_should_behave_like "a control method"
+      end
+
+      context "#stop" do
+        context " and the request is not forced (force == false)" do
+          let(:control_data) { { :method => :stop } }
+          it_should_behave_like "a control method"
+        end
+        context " and the request is forced (force == true)" do
+          let(:control_data) { { :method => :stop, :arg => true, :event => 'force-stop', :link => 'stop' } }
+          it_should_behave_like "a control method"
+        end
+      end
+
+      context "#restart" do
+        let(:control_data) { { :method => :restart } }
+        it_should_behave_like "a control method"
+      end
+
+      context "#delete" do
+        let(:control_data) { { :method => :delete, :payload => false } }
+        it_should_behave_like "a control method"
+      end
+
+      context "#destroy" do
+        let(:control_data) { { :method => :destroy, :event => 'delete', :link => 'delete', :payload => false } }
+        it_should_behave_like "a control method"
+      end
+
+      context "#scale_up" do
+        let(:control_data) { { :method => :scale_up, :event => 'scale-up', :link => 'scale_up', :payload => false } }
+        it_should_behave_like "a control method"
+      end
+
+      context "#scale_down" do
+        let(:control_data) { { :method => :scale_down, :event => 'scale-down', :link => 'scale_down', :payload => false } }
+        it_should_behave_like "a control method"
+      end
+    end
+  end
+end
+