rhc 0.96.9 → 0.97.17

data/lib/rhc/version.rb

@@ -1,8 +1,8 @@
 module RHC
   module VERSION #:nocov:
     MAJOR = 0
-    MINOR = 96
-    MICRO = 9
+    MINOR = 97
+    MICRO = 17
     #PRE  = ''
     STRING = [MAJOR,MINOR,MICRO].compact.join('.')
   end

data/lib/rhc/wizard.rb

@@ -24,10 +24,11 @@ module RHC
       STAGES
     end
 
-    def initialize(config_path)
-      @config_path = config_path
+    def initialize(config)
+      @config = config
+      @config_path = config.config_path
       if @libra_server.nil?
-        @libra_server = get_var('libra_server')
+        @libra_server = config['libra_server']
         # if not set, set to default
         @libra_server = @libra_server ?  @libra_server : "openshift.redhat.com"
       end
@@ -51,6 +52,10 @@ module RHC
       true
     end
 
+    def needs_configuration?
+      not (@config.has_local_config? or @config.has_opts_config? or @config.noprompt?)
+    end
+
     private
 
     def greeting_stage
@@ -540,7 +545,7 @@ EOF
   end
 
   class RerunWizard < Wizard
-    def initialize(config_path)
+    def initialize(config)
       super
     end
 
@@ -595,7 +600,7 @@ EOF
     def initialize(username, password)
       @username = username
       @password = password
-      super("")
+      super RHC::Config
     end
   end
 end

data/spec/coverage_helper.rb

@@ -35,7 +35,6 @@ unless RUBY_VERSION < '1.9'
     add_filter 'features/'         # Don't report on the files that run the cucumber tests
     add_filter 'lib/rhc-feature-coverage-helper.rb'
     add_filter 'spec/'             # Don't report on the files that run the spec tests
-    add_filter 'lib/rhc/help_formatter.rb'
 
     # Groups - general categories of test areas
     add_group('Commands') { |src_file| src_file.filename.include?(File.join(%w[lib rhc commands])) }

data/spec/rest_spec_helper.rb

@@ -1,4 +1,6 @@
 require 'webmock/rspec'
+require 'rhc-rest'
+require 'rhc/exceptions'
 
 Spec::Matchers.define :have_same_attributes_as do |expected|
   match do |actual|
@@ -110,4 +112,97 @@ module RestSpecHelper
       :status => 200
     }
   end
+
+  class MockRestClient < Rhc::Rest::Client
+    def initialize
+      Rhc::Rest::Client.stub(:new) { self }
+      @domains = []
+    end
+
+    def domains
+      @domains
+    end
+
+    def add_domain(id)
+      d = MockRestDomain.new(id, self)
+      @domains << d
+      d
+    end
+  end
+
+  class MockRestDomain
+    attr_reader :id
+
+    def initialize(id, client)
+      @id = id
+      @client = client
+      @applications = []
+    end
+
+    def update(id)
+      @id = id
+      self
+    end
+
+    def destroy
+      @client.domains.delete_if do |d|
+        match = (d.id == @id)
+        raise Rhc::Rest::ClientErrorException.new("Mock error.  Trying to delete domain with apps.", 128) if match and not applications.empty?
+        match
+      end
+
+      @client = nil
+      @applications = nil
+    end
+
+    def add_application(name, type)
+      a = MockRestApplication.new(name, type, self)
+      @applications << a
+      a
+    end
+
+    def applications
+      @applications
+    end
+  end
+
+  class MockRestApplication
+    attr_reader :name, :uuid, :creation_time, :git_url, :app_url, :aliases
+
+    def initialize(name, type, domain)
+      @name = name
+      @domain = domain
+      @cartridges = []
+      @creation_time = "now"
+      @uuid = "fakeuuidfortests"
+      @git_url = "git:fake.foo/git/#{@name}.git"
+      @app_url = "https://#{@name}-#{@domain.id}.fake.foo/"
+      @aliases = []
+      add_cartridge(type, false)
+    end
+
+    def add_cartridge(name, embedded=true)
+      type = embedded ? "embedded" : "framework"
+      c = MockRestCartridge.new(name, type, self)
+      @cartridges << c
+      c
+    end
+
+    def cartridges
+      @cartridges
+    end
+  end
+
+  class MockRestCartridge < Rhc::Rest::Cartridge
+    attr_reader :name
+    attr_reader :type
+    attr_reader :properties
+
+    def initialize(name, type, app, properties={:cart_data => {:connection_url => {'value' => "http://fake.url" }}})
+      @name = name
+      @type = type
+      @app = app
+      @properties = properties
+    end
+  end
 end

data/spec/rhc/cli_spec.rb

@@ -5,7 +5,7 @@ describe RHC::CLI do
   shared_examples_for 'a help page' do
     let(:arguments) { @arguments or raise "no arguments" }
     it('should contain the program description') { run_output.should =~ /Command line interface for OpenShift/ }
-    it('should contain the global options') { run_output.should =~ /Global Options:/ }
+    it('should contain the global options') { run_output.should =~ /Global Options/ }
     it('should provide a --config switch') { run_output.should =~ /\-\-config FILE/ }
   end
 
@@ -16,11 +16,16 @@ describe RHC::CLI do
       it('should provide a message about --help') { run_output.should =~ /\-\-help/ }
     end
 
+    context 'with help and invalid command' do
+      let(:arguments) { ['invalidcommand', 'help'] }
+      it { expect { run }.should exit_with_code(1) }
+    end
+
     context 'with --help' do
       before(:each){ @arguments = ['--help'] }
       it_should_behave_like 'a help page'
     end
-    
+
     context 'with -h' do
       before(:each){ @arguments = ['-h'] }
       it_should_behave_like 'a help page'

data/spec/rhc/command_spec.rb

@@ -2,13 +2,12 @@ require 'spec_helper'
 require 'rhc/commands/base'
 
 describe RHC::Commands::Base do
-
   describe '#object_name' do
     subject { described_class }
     its(:object_name) { should == 'base' }
 
     context 'when the class is at the root' do
-      subject do 
+      subject do
         Kernel.module_eval do 
           class StaticRootClass < RHC::Commands::Base; def run; 1; end; end
         end
@@ -34,16 +33,32 @@ describe RHC::Commands::Base do
 
     context 'when dynamically instantiating without an object name' do
       subject { const_for(Class.new(RHC::Commands::Base) { def run; 1; end }) }
-      
+
       it("should raise") { expect { subject }.to raise_exception( RHC::Commands::Base::InvalidCommand, /object_name/i ) }
     end
 
     context 'when dynamically instantiating with object_name' do
       subject { const_for(Class.new(RHC::Commands::Base) { object_name :test; def run(args, options); 1; end }) }
-      
+
       it("should register itself") { expect { subject }.to change(commands, :length).by(1) }
       it("should have an object name") { subject.object_name.should == 'test' }
-      it { expects_running('test').should call(:run).on(instance).with(no_args) }
+      it("should run with wizard") do
+        FakeFS.activate!
+
+        wizard_run = false
+        RHC::Wizard.stub!(:new) do |config|
+          RHC::Wizard.unstub!(:new)
+          w = RHC::Wizard.new(config)
+          w.stub!(:run) { wizard_run = true }
+          w
+        end
+
+        expects_running('test').should call(:run).on(instance).with(no_args)
+        wizard_run.should be_true
+
+        FakeFS::FileSystem.clear
+        FakeFS.deactivate!
+      end
     end
 
     context 'when statically defined' do
@@ -51,37 +66,68 @@ describe RHC::Commands::Base do
         Kernel.module_eval do 
           module Nested
             class Static < RHC::Commands::Base
+              suppress_wizard
               def run(args, options); 1; end
             end
           end
         end
         Nested::Static
       end
-      
+
       it("should register itself") { expect { subject }.to change(commands, :length).by(1) }
       it("should have an object name of the class") { subject.object_name.should == 'static' }
       it("invokes the right method") { expects_running('static').should call(:run).on(instance).with(no_args) }
     end
 
     context 'when statically defined with no default method' do
-      subject do 
-        Kernel.module_eval do 
+      subject do
+        Kernel.module_eval do
           class Static < RHC::Commands::Base
+            suppress_wizard
+
             def test; 1; end
+
+            argument :testarg, "Test arg", "--testarg testarg"
+            summary "Test command execute"
             def execute; 1; end
+            def raise_exception
+              raise Exception.new("test exception")
+            end
           end
         end
         Static
       end
-      
-      it("should register itself") { expect { subject }.to change(commands, :length).by(2) }
+
+      it("should register itself") { expect { subject }.to change(commands, :length).by(3) }
       it("should have an object name of the class") { subject.object_name.should == 'static' }
-      
+
       context 'and when test is called' do
         it { expects_running('static', 'test').should call(:test).on(instance).with(no_args) }
       end
-      context 'and when test is called' do
-        it { expects_running('static', 'execute').should call(:execute).on(instance).with(no_args) }
+      context 'and when execute is called with argument' do
+        it { expects_running('static', 'execute', 'simplearg').should call(:execute).on(instance).with('simplearg') }
+      end
+      context 'and when execute is called with argument switch' do
+        it { expects_running('static', 'execute', '--testarg', 'switcharg').should call(:execute).on(instance).with('switcharg') }
+      end
+      context 'and when execute is called with same argument and switch' do
+        it { expects_running('statis', 'execute', 'duparg', '--testarg', 'duparg2').should exit_with_code(1) }
+      end
+
+      context 'and when execute is called with too many arguments' do
+        it { expects_running('static', 'execute', 'arg1', 'arg2').should exit_with_code(1) }
+      end
+
+      context 'and when execute is called with a missing argument' do
+        it { expects_running('static', 'execute').should exit_with_code(1) }
+      end
+
+      context 'and when an exception is raised in a call' do
+        it { expects_running('static', 'raise_exception').should exit_with_code(128) }
+      end
+
+      context 'and when an exception is raised in a call with --trace option' do
+        it { expects_running('static', 'raise_exception', "--trace").should raise_error(Exception, "test exception") }
       end
     end
   end

data/spec/rhc/commands/domain_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper'
+require 'rest_spec_helper'
+require 'rhc/commands/domain'
+require 'rhc/config'
+
+describe RHC::Commands::Domain do
+  before(:each) do
+    RHC::Config.set_defaults
+  end
+
+  describe 'run' do
+    let(:arguments) { ['domain', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password'] }
+
+    context 'when run with no domains' do
+      before(:each) do
+        @rc = MockRestClient.new
+      end
+      it { expect { run }.should exit_with_code(0) }
+      it { run_output.should match("Namespace: No namespaces found") }
+    end
+
+    context 'when run with one domain no apps' do
+      before(:each) do
+        @rc = MockRestClient.new
+        @rc.add_domain("onedomain")
+      end
+      it { expect { run }.should exit_with_code(0) }
+      it "should match output" do
+        output = run_output
+        output.should match("Namespace onedomain's Applications")
+        output.should match("No applications found")
+      end
+    end
+
+    context 'when run with multiple domain no apps' do
+      before(:each) do
+        @rc = MockRestClient.new
+        @rc.add_domain("firstdomain")
+        @rc.add_domain("seconddomain")
+      end
+      it { expect { run }.should exit_with_code(0) }
+      it "should match output" do
+        output = run_output
+        output.should match("Namespace\\(0\\): firstdomain")
+        output.should match("Namespace\\(1\\): seconddomain")
+        output.should match("Namespace firstdomain's Applications")
+        output.should match("Namespace seconddomain's Applications")
+      end
+    end
+
+    context 'when run with one domain multiple apps' do
+      before(:each) do
+        @rc = MockRestClient.new
+        d = @rc.add_domain("appdomain")
+        a = d.add_application("app_no_carts", "testframework-1.0")
+        a = d.add_application("app_multi_carts", "testframework-1.0")
+        a.add_cartridge("testcart-1")
+        a.add_cartridge("testcart-2")
+        a.add_cartridge("testcart-3")
+      end
+      it { expect { run }.should exit_with_code(0) }
+      it "should match output" do
+        output = run_output
+        output.should match("app_no_carts")
+        output.should match("None")
+        output.should match("app_multi_carts")
+        output.should match("testframework-1.0")
+        output.should match("testcart-1")
+        output.should match("testcart-2")
+        output.should match("testcart-3")
+      end
+    end
+  end
+
+  describe 'create' do
+    let(:arguments) { ['domain', 'create', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password', 'testnamespace'] }
+
+    context 'when no issues with ' do
+      before(:each) do
+        @rc = MockRestClient.new
+      end
+
+      it "should create a domain" do
+        expect { run }.should exit_with_code(0)
+        @rc.domains[0].id.should == 'testnamespace'
+      end
+      it { run_output.should match(/'testnamespace'\n\nRESULT:\n.*Success/m) }
+    end
+  end
+
+  describe 'update' do
+    let(:arguments) { ['domain', 'update', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password', 'alterednamespace'] }
+
+    context 'when no issues with ' do
+      before(:each) do
+        @rc = MockRestClient.new
+        @rc.add_domain("olddomain")
+      end
+
+      it "should update a domain" do
+        expect { run }.should exit_with_code(0)
+        @rc.domains[0].id.should == 'alterednamespace'
+      end
+      it { run_output.should match(/Updating domain 'olddomain' to namespace 'alterednamespace'\n\nRESULT:\n.*Success/m) }
+    end
+
+    context 'when there is no domain' do
+      before(:each) do
+        @rc = MockRestClient.new
+      end
+
+      it "should not create a domain" do
+        expect { run }.should exit_with_code(127)
+        @rc.domains.empty?.should be_true
+      end
+      it { run_output.should match("No domains are registered to the user test@test.foo") }
+    end
+  end
+
+  describe 'alter alias' do
+    let(:arguments) { ['domain', 'alter', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password', 'alterednamespace'] }
+
+    context 'when no issues with ' do
+      before(:each) do
+        @rc = MockRestClient.new
+        @rc.add_domain("olddomain")
+      end
+
+      it "should update a domain" do
+        expect { run }.should exit_with_code(0)
+        @rc.domains[0].id.should == 'alterednamespace'
+      end
+      it { run_output.should match(/Updating domain 'olddomain' to namespace 'alterednamespace'\n\nRESULT:\n.*Success/m) }
+    end
+  end
+
+  describe 'delete' do
+    let(:arguments) { ['domain', 'delete', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password', 'deleteme'] }
+
+    context 'when no issues with ' do
+      before(:each) do
+        @rc = MockRestClient.new
+        @rc.add_domain("deleteme")
+      end
+
+      it "should delete a domain" do
+        expect { run }.should exit_with_code(0)
+        @rc.domains.empty?.should be_true
+      end
+    end
+
+    context 'when there is a different domain' do
+      before(:each) do
+        @rc = MockRestClient.new
+        @rc.add_domain("dontdelete")
+      end
+
+      it "should error out" do
+        expect { run }.should exit_with_code(127)
+        @rc.domains[0].id.should == 'dontdelete'
+      end
+      it { run_output.should match("Domain deleteme does not exist") }
+    end
+  end
+
+  describe 'alias destroy' do
+    let(:arguments) { ['domain', 'destroy', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password', 'deleteme'] }
+
+    context 'when no issues with ' do
+      before(:each) do
+        @rc = MockRestClient.new
+        @rc.add_domain("deleteme")
+      end
+
+      it "should delete a domain" do
+        expect { run }.should exit_with_code(0)
+        @rc.domains.empty?.should be_true
+      end
+    end
+
+    context 'when domain contains app' do
+      before(:each) do
+        @rc = MockRestClient.new
+        d = @rc.add_domain("deleteme")
+        d.add_application("app1", "testframework-1.0")
+      end
+
+      it "should fail to delete domain" do
+        expect { run }.should exit_with_code(128)
+        @rc.domains.empty?.should be_false
+      end
+    end
+  end
+
+  describe 'status' do
+    let(:arguments) { ['domain', 'status', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password'] }
+
+    before(:each) do
+      Kernel.stub!(:system) do |cmd| 
+        @cmd = cmd
+        # run the true command to get $?.exitstatus == 0
+        system("true")
+      end
+    end
+
+    context 'rhc-chk should be executed' do
+      it "runs" do 
+        expect { run }.should exit_with_code(0)
+        # check lengths here because different versions of ruby output the switches in different order
+        @cmd.length.should == "rhc-chk --noprompt true --config test.conf --rhlogin test@test.foo --password password 2>&1".length
+      end
+    end
+  end
+
+  describe 'help' do
+    let(:arguments) { ['domain', 'help'] }
+
+    context 'help is run' do
+      it "should display help" do
+        expect { run }.should exit_with_code(0)
+      end
+      it('should output usage') { run_output.should match("Usage: rhc domain") }
+    end
+  end
+end