pbox 1.17.2

data/spec/rhc/commands/deployment_spec.rb

@@ -0,0 +1,286 @@
+require 'spec_helper'
+require 'rest_spec_helper'
+require 'rhc/commands/deployment'
+
+describe RHC::Commands::Deployment do
+
+  DEPLOYMENT_APP_NAME = 'mock_app_deploy'
+
+  let!(:rest_client) { MockRestClient.new }
+
+  before do
+    user_config
+    @rest_app = rest_client.add_domain("mock_domain").add_application(DEPLOYMENT_APP_NAME, 'ruby-1.8.7')
+    @rest_app.stub(:ssh_url).and_return("ssh://user@test.domain.com")
+    @targz_filename = File.dirname(__FILE__) + '/' + DEPLOYMENT_APP_NAME + '.tar.gz'
+    FileUtils.cp(File.expand_path('../../assets/targz_sample.tar.gz', __FILE__), @targz_filename)
+    File.chmod 0644, @targz_filename unless File.executable? @targz_filename
+  end
+
+  after do
+    File.delete @targz_filename if File.exist? @targz_filename
+  end
+
+  describe "configure app" do
+    context "manual deployment keeping a history of 10" do
+      let(:arguments) {['app', 'configure', '--app', DEPLOYMENT_APP_NAME, '--no-auto-deploy', '--keep-deployments', '10']}
+      it "should succeed" do
+        expect{ run }.to exit_with_code(0)
+        run_output.should match(/Configuring application '#{DEPLOYMENT_APP_NAME}' .../)
+        run_output.should match(/done/)
+        @rest_app.auto_deploy.should == false
+        @rest_app.keep_deployments.should == 10
+        run_output.should match(/Your application '#{DEPLOYMENT_APP_NAME}' is now configured as listed above/)
+      end
+    end
+
+    context "with no configuration options" do
+      let(:arguments) {['app', 'configure', '--app', DEPLOYMENT_APP_NAME]}
+      it "should display the current configuration" do
+        expect{ run }.to exit_with_code(0)
+        run_output.should_not match(/Configuring application '#{DEPLOYMENT_APP_NAME}' .../)
+        run_output.should_not match(/done/)
+        run_output.should match(/Your application '#{DEPLOYMENT_APP_NAME}' is configured as listed above/)
+      end
+    end
+  end
+
+  describe "deploy" do
+    context "git ref successfully" do
+      before { Net::SSH.should_receive(:start).exactly(3).times.with('test.domain.com', 'user', :compression=>false) }
+      let(:arguments) {['app', 'deploy', 'master', '--app', DEPLOYMENT_APP_NAME]}
+      it "should succeed" do
+        expect{ run }.to exit_with_code(0)
+        run_output.should match(/Deployment of git ref 'master' in progress for application #{DEPLOYMENT_APP_NAME} .../)
+        run_output.should match(/Success/)
+      end
+    end
+
+    context "binary file successfully" do
+      before do
+        ssh = double(Net::SSH)
+        session = double(Net::SSH::Connection::Session)
+        channel = double(Net::SSH::Connection::Channel)
+        exit_status = double(Net::SSH::Buffer)
+        exit_status.stub(:read_long).and_return(0)
+        Net::SSH.should_receive(:start).exactly(3).times.with('test.domain.com', 'user', :compression=>false).and_yield(session)
+        session.should_receive(:open_channel).exactly(3).times.and_yield(channel)
+        channel.should_receive(:exec).exactly(3).times.with("oo-binary-deploy").and_yield(nil, nil)
+        channel.should_receive(:on_data).exactly(3).times.and_yield(nil, 'foo')
+        channel.should_receive(:on_extended_data).exactly(3).times.and_yield(nil, nil, '')
+        channel.should_receive(:on_close).exactly(3).times.and_yield(nil)
+        channel.should_receive(:on_request).exactly(3).times.with("exit-status").and_yield(nil, exit_status)
+        lines = ''
+        File.open(@targz_filename, 'rb') do |file|
+          file.chunk(1024) do |chunk|
+            lines << chunk
+          end
+        end
+        channel.should_receive(:send_data).exactly(3).times.with(lines)
+        channel.should_receive(:eof!).exactly(3).times
+        session.should_receive(:loop).exactly(3).times
+      end
+      let(:arguments) {['app', 'deploy', @targz_filename, '--app', DEPLOYMENT_APP_NAME]}
+      it "should succeed" do
+        expect{ run }.to exit_with_code(0)
+        run_output.should match(/Deployment of file '#{@targz_filename}' in progress for application #{DEPLOYMENT_APP_NAME} .../)
+        run_output.should match(/Success/)
+      end
+    end
+
+    [URI('http://foo.com/path/to/file/' + DEPLOYMENT_APP_NAME + '.tar.gz'),
+     URI('https://foo.com/path/to/file/' + DEPLOYMENT_APP_NAME + '.tar.gz')].each do |uri|
+      context "url file successfully" do
+        before do
+          ssh = double(Net::SSH)
+          session = double(Net::SSH::Connection::Session)
+          channel = double(Net::SSH::Connection::Channel)
+          exit_status = double(Net::SSH::Buffer)
+          exit_status.stub(:read_long).and_return(0)
+          Net::SSH.should_receive(:start).exactly(3).times.with('test.domain.com', 'user', :compression=>false).and_yield(session)
+          session.should_receive(:open_channel).exactly(3).times.and_yield(channel)
+          channel.should_receive(:exec).exactly(3).times.with("oo-binary-deploy").and_yield(nil, nil)
+          channel.should_receive(:on_data).exactly(3).times.and_yield(nil, 'foo')
+          channel.should_receive(:on_extended_data).exactly(3).times.and_yield(nil, nil, '')
+          channel.should_receive(:on_close).exactly(3).times.and_yield(nil)
+          channel.should_receive(:on_request).exactly(3).times.with("exit-status").and_yield(nil, exit_status)
+          lines = ''
+          File.open(@targz_filename, 'rb') do |file|
+            file.chunk(1024) do |chunk|
+              lines << chunk
+            end
+          end
+          stub_request(:get, uri.to_s).to_return(:status => 200, :body => lines, :headers => {})
+          channel.should_receive(:send_data).exactly(3).times.with(lines)
+          channel.should_receive(:eof!).exactly(3).times
+          session.should_receive(:loop).exactly(3).times
+        end
+        let(:arguments) {['app', 'deploy', uri.to_s, '--app', DEPLOYMENT_APP_NAME]}
+        it "should succeed" do
+          expect{ run }.to exit_with_code(0)
+          run_output.should match(/Deployment of file '#{uri.to_s}' in progress for application #{DEPLOYMENT_APP_NAME} .../)
+          run_output.should match(/Success/)
+        end
+      end
+    end
+
+    context "binary file with corrupted file" do
+      before do
+        ssh = double(Net::SSH)
+        session = double(Net::SSH::Connection::Session)
+        channel = double(Net::SSH::Connection::Channel)
+        exit_status = double(Net::SSH::Buffer)
+        exit_status.stub(:read_long).and_return(255)
+        Net::SSH.should_receive(:start).exactly(3).times.with('test.domain.com', 'user', :compression=>false).and_yield(session)
+        session.should_receive(:open_channel).exactly(3).times.and_yield(channel)
+        channel.should_receive(:exec).exactly(3).times.with("oo-binary-deploy").and_yield(nil, nil)
+        channel.should_receive(:on_data).exactly(3).times.and_yield(nil, 'foo')
+        channel.should_receive(:on_extended_data).exactly(3).times.and_yield(nil, nil, 'Invalid file')
+        channel.should_receive(:on_close).exactly(3).times.and_yield(nil)
+        channel.should_receive(:on_request).exactly(3).times.with("exit-status").and_yield(nil, exit_status)
+        lines = ''
+        File.open(@targz_filename, 'rb') do |file|
+          file.chunk(1024) do |chunk|
+            lines << chunk
+          end
+        end
+        channel.should_receive(:send_data).exactly(3).times.with(lines)
+        channel.should_receive(:eof!).exactly(3).times
+        session.should_receive(:loop).exactly(3).times
+      end
+      let(:arguments) {['app', 'deploy', @targz_filename, '--app', DEPLOYMENT_APP_NAME]}
+      it "should not succeed" do
+        expect{ run }.to exit_with_code(133)
+        run_output.should match(/Deployment of file '#{@targz_filename}' in progress for application #{DEPLOYMENT_APP_NAME} .../)
+        run_output.should match(/Invalid file/)
+      end
+    end
+
+    context "fails when deploying git ref" do
+      before (:each) { Net::SSH.should_receive(:start).and_raise(Errno::ECONNREFUSED) }
+      let(:arguments) {['app', 'deploy', 'master', '--app', DEPLOYMENT_APP_NAME]}
+      it "should exit with error" do
+        expect{ run }.to exit_with_code(1)
+      end
+    end
+
+    context "fails when deploying binary file" do
+      before (:each) { Net::SSH.should_receive(:start).and_raise(Errno::ECONNREFUSED) }
+      let(:arguments) {['app', 'deploy', @targz_filename, '--app', DEPLOYMENT_APP_NAME]}
+      it "should exit with error" do
+        expect{ run }.to exit_with_code(1)
+      end
+    end
+
+    context "fails when deploying binary file" do
+      before (:each) { Net::SSH.should_receive(:start).and_raise(SocketError) }
+      let(:arguments) {['app', 'deploy', @targz_filename, '--app', DEPLOYMENT_APP_NAME]}
+      it "should exit with error" do
+        expect{ run }.to exit_with_code(1)
+      end
+    end
+
+    context "fails when deploying url file" do
+      before (:each) { Net::SSH.should_receive(:start).and_raise(Errno::ECONNREFUSED) }
+      let(:arguments) {['app', 'deploy', 'http://foo.com/deploy.tar.gz', '--app', DEPLOYMENT_APP_NAME]}
+      it "should exit with error" do
+        expect{ run }.to exit_with_code(1)
+      end
+    end
+
+    context "fails when deploying url file" do
+      before (:each) { Net::SSH.should_receive(:start).and_raise(SocketError) }
+      let(:arguments) {['app', 'deploy', 'http://foo.com/deploy.tar.gz', '--app', DEPLOYMENT_APP_NAME]}
+      it "should exit with error" do
+        expect{ run }.to exit_with_code(1)
+      end
+    end
+
+    context 'when run against an unsupported server' do
+      before {
+        @rest_app.links.delete 'UPDATE'
+        @rest_app.links.delete 'DEPLOY'
+      }
+      let(:arguments) {['app', 'deploy', 'master', '--app', DEPLOYMENT_APP_NAME]}
+      it "should raise not supported exception" do
+        expect{ run }.to exit_with_code(132)
+        run_output.should match(/The server does not support deployments/)
+      end
+    end
+
+    context "ssh authentication failure" do
+      before (:each) { Net::SSH.should_receive(:start).exactly(2).times.and_raise(Net::SSH::AuthenticationFailed) }
+      let(:arguments) {['app', 'deploy', 'master', '--app', DEPLOYMENT_APP_NAME]}
+      it "should exit with error" do
+        expect{ run }.to exit_with_code(1)
+        run_output.should match(/Authentication to server test.domain.com with user user failed/)
+      end
+    end
+
+  end
+
+  describe "activate deployment" do
+    context "activates 123456" do
+      before { Net::SSH.should_receive(:start).exactly(3).times.with('test.domain.com', 'user', :compression => false) }
+      let(:arguments) {['deployment', 'activate', '123456', '--app', DEPLOYMENT_APP_NAME]}
+      it "should succeed" do
+        expect{ run }.to exit_with_code(0)
+        run_output.should match(/Activating deployment '123456' on application #{DEPLOYMENT_APP_NAME} .../)
+        run_output.should match(/Success/)
+      end
+    end
+
+    context "fails with ssh error" do
+      before (:each) { Net::SSH.should_receive(:start).and_raise(Errno::ECONNREFUSED) }
+      let(:arguments) {['deployment', 'activate', '123456', '--app', DEPLOYMENT_APP_NAME]}
+      it "should exit with error" do
+        expect{ run }.to exit_with_code(1)
+      end
+    end
+  end
+
+  describe "list deployments" do
+    context "simple" do
+      let(:arguments) {['deployment', 'list', DEPLOYMENT_APP_NAME]}
+      it "should succeed" do
+        expect{ run }.to exit_with_code(0)
+        run_output.should match(/Jan 01\, 2000  1\:00 AM\, deployment 0000001/)
+        run_output.should match(/Jan 01\, 2000  2\:00 AM\, deployment 0000002/)
+        run_output.should match(/Jan 01\, 2000  3\:00 AM\, deployment 0000003 \(rolled back\)/)
+        run_output.should match(/Jan 01\, 2000  4\:00 AM\, deployment 0000004 \(rolled back\)/)
+        run_output.should match(/Jan 01\, 2000  5\:00 AM\, deployment 0000003 \(rollback to Jan 01\, 2000  3\:00 AM\, rolled back\)/)
+        run_output.should match(/Jan 01\, 2000  5\:00 AM\, deployment 0000005 \(rolled back\)/)
+        run_output.should match(/Jan 01\, 2000  6\:00 AM\, deployment 0000002 \(rollback to Jan 01\, 2000  2\:00 AM\)/)
+      end
+    end
+  end
+
+  describe "show deployment" do
+    context "simple" do
+      let(:arguments) {['deployment', 'show', '0000001', '--app', DEPLOYMENT_APP_NAME]}
+      it "should succeed" do
+        expect{ run }.to exit_with_code(0)
+        run_output.should match(/Deployment ID 0000001/)
+      end
+    end
+
+    context "fails when deployment is not found" do
+      let(:arguments) {['deployment', 'show', 'zee', '--app', DEPLOYMENT_APP_NAME]}
+      it "should succeed" do
+        expect{ run }.to exit_with_code(131)
+        run_output.should match(/Deployment ID 'zee' not found for application #{DEPLOYMENT_APP_NAME}/)
+      end
+    end
+  end
+
+  describe "show configuration" do
+    context "simple" do
+      let(:arguments) {['app', 'show', '--app', DEPLOYMENT_APP_NAME, '--configuration']}
+      it "should succeed" do
+        expect{ run }.to exit_with_code(0)
+        #run_output.should match(/Deployment ID 1/)
+      end
+    end
+  end
+
+end

data/spec/rhc/commands/domain_spec.rb

@@ -0,0 +1,383 @@
+require 'spec_helper'
+require 'rest_spec_helper'
+require 'rhc/commands/domain'
+
+describe RHC::Commands::Domain do
+  let(:rest_client){ MockRestClient.new }
+  before{ user_config }
+
+  describe 'default action' do
+    before{ rest_client }
+    context 'when run with no domains' do
+      let(:arguments) { ['domain'] }
+
+      it { expect { run }.to exit_with_code(1) }
+      it { run_output.should match(/To create your first domain.*pbox create-domain/m) }
+    end
+    context 'when help is shown' do
+      let(:arguments) { ['domain', '--noprompt', '--help'] }
+
+      it { expect { run }.to exit_with_code(0) }
+      it { run_output.should match(/configure.*delete.*leave.*list.*rename/m) }
+    end
+  end
+
+  describe 'show' do
+    before{ rest_client }
+    let(:arguments) { ['domain', 'show'] }
+
+    context 'when run with no domains' do
+      it { expect { run }.to exit_with_code(1) }
+      it { run_output.should match(/In order to deploy applications, you must create a domain/m) }
+    end
+
+    context 'when run with one domain no apps' do
+      before{ rest_client.add_domain("onedomain") }
+
+      it { expect { run }.to exit_with_code(0) }
+      it "should match output" do
+        output = run_output
+        output.should match("The domain onedomain exists but has no applications. You can use")
+      end
+    end
+
+    context 'when run with multiple domain no apps' do
+      before do
+        rest_client.add_domain("firstdomain")
+        rest_client.add_domain("seconddomain")
+      end
+      it { expect { run }.to exit_with_code(0) }
+      it "should match output" do
+        output = run_output
+        output.should match("The domain firstdomain exists but has no applications. You can use")
+        output.should_not match("Applications in seconddomain")
+      end
+    end
+
+    context 'when run with one domain multiple apps' do
+      before do
+        d = rest_client.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 }.to exit_with_code(0) }
+      it "should match output" do
+        output = run_output
+        output.should match("app_no_carts")
+        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
+
+    context 'when run with an app without cartridges' do
+      before do
+        d = rest_client.add_domain("appdomain")
+        a = d.add_application("app_no_carts")
+      end
+      it { expect { run }.to exit_with_code(0) }
+      it "should match output" do
+        output = run_output
+        output.should match("app_no_carts")
+        output.should match(/127.0.0.1\s*$/m)
+      end
+    end
+  end
+
+
+  describe 'list' do
+    before{ rest_client }
+    let(:arguments) { ['domain', 'list'] }
+
+    context 'when run with no domains' do
+      it { expect { run }.to exit_with_code(1) }
+      it { run_output.should match(/In order to deploy applications.*pbox create-domain/) }
+    end
+
+    context 'when run with one domain no apps' do
+      before{ rest_client.add_domain("onedomain") }
+
+      it { expect { run }.to exit_with_code(0) }
+      it "should match output" do
+        output = run_output
+        output.should match("You have access to 1 domain\\.")
+        output.should match("onedomain")
+      end
+
+      context 'when has no creation date, members, or allowed_gear_sizes' do
+        before{ rest_client.domains.first.attributes.merge(:creation_date => nil, :allowed_gear_sizes => nil, :members => nil, :id => '123') }
+        it { expect { run }.to exit_with_code(0) }
+        it "should match output" do
+          output = run_output
+          output.should match("onedomain")
+          output.should_not match ("Allowed Gear Sizes:")
+          output.should_not match ("Created:")
+          output.should_not match ("Members:")
+          output.should_not match ("ID:.*")
+        end
+      end
+      context 'when an ID is present and differs from name' do
+        let(:arguments) { ['domain', 'list', '--ids'] }
+        before{ rest_client.domains.first.attributes['id'] = '123' }
+        it { expect { run }.to exit_with_code(0) }
+        it "should match output" do
+          output = run_output
+          output.should match("onedomain")
+          output.should match ("ID:.*123")
+        end
+      end
+      context 'when an ID is present and identical to name' do
+        let(:arguments) { ['domain', 'list', '--ids'] }
+        before{ rest_client.domains.first.attributes['id'] = 'onedomain' }
+        it { expect { run }.to exit_with_code(0) }
+        it "should not match output" do
+          run_output.should_not match ("ID:.*123")
+        end
+      end
+      context 'when an ID is present and name is not' do
+        let(:arguments) { ['domain', 'list', '--ids'] }
+        before{ rest_client.domains.first.attributes['id'] = 'onedomain' }
+        before{ rest_client.domains.first.instance_variable_set(:@name, nil) }
+        it { expect { run }.to exit_with_code(0) }
+        it "should match output" do
+          run_output.should match ("onedomain")
+          run_output.should_not match ("ID:.*")
+        end
+      end
+    end
+
+    context 'when run with one owned domain' do
+      let(:arguments) { ['domains', '--mine'] }
+      before{ d = rest_client.add_domain('mine', true); rest_client.stub(:owned_domains).and_return([d]) }
+
+      it { expect { run }.to exit_with_code(0) }
+      it "should match output" do
+        output = run_output
+        output.should match("You have access to 1 domain\\.")
+        output.should match("mine")
+        output.should match("Created")
+        output.should match("Allowed Gear Sizes: small")
+      end
+    end
+
+    context 'when run with multiple domains and extra domain info' do
+      before do
+        rest_client.add_domain("firstdomain")
+        rest_client.add_domain("seconddomain", true)
+      end
+      it { expect { run }.to exit_with_code(0) }
+      it "should match output" do
+        output = run_output
+        output.should match("You have access to 2 domains")
+        output.should match("seconddomain \\(owned by a_user_name\\)")
+        output.should match("Created")
+        output.should match("Allowed Gear Sizes: small")
+      end
+    end
+  end
+
+  describe 'create' do
+    before{ rest_client }
+    let(:arguments) { ['domain', 'create', 'testnamespace'] }
+
+    context 'when no issues with ' do
+
+      it "should create a domain" do
+        expect { run }.to exit_with_code(0)
+        rest_client.domains[0].name.should == 'testnamespace'
+      end
+      it { run_output.should match(/Creating.*'testnamespace'.*done/m) }
+    end
+  end
+
+  describe 'rename' do
+    before{ rest_client }
+    let(:arguments) { ['domain', 'rename', 'olddomain', 'alterednamespace'] }
+
+    context 'when no issues with ' do
+      before{ rest_client.add_domain("olddomain") }
+
+      it "should update a domain" do
+        expect { run }.to exit_with_code(0)
+        rest_client.domains[0].name.should == 'alterednamespace'
+      end
+      it { run_output.should match(/Renaming domain 'olddomain' to 'alterednamespace'.*done.*?Applications in this domain will use the new name in their URL./m) }
+    end
+
+    context 'when there is no domain' do
+      it "should not create a domain" do
+        expect { run }.to exit_with_code(127)
+        rest_client.domains.empty?.should be_true
+      end
+      it { run_output.should match("not found") }
+    end
+  end
+
+  describe 'update' do
+    before{ rest_client }
+    let(:arguments) { ['domain', 'update', 'olddomain', 'alterednamespace'] }
+
+    before{ rest_client.add_domain("olddomain") }
+    it "should update a domain" do
+      expect { run }.to exit_with_code(0)
+      rest_client.domains[0].name.should == 'alterednamespace'
+    end
+    it { run_output.should match(/This command is deprecated.*Renaming domain 'olddomain' to 'alterednamespace'.*done.*?Applications in this domain will use the new name in their URL./m) }
+  end
+
+  describe 'alter alias has been removed' do
+    let(:arguments) { ['domain', 'alter', 'olddomain', 'alterednamespace'] }
+    it{ expect { run }.to exit_with_code(1) }
+  end
+
+  describe 'configure' do
+    context "no settings" do
+      before{ rest_client.add_domain("domain1") }
+      let(:arguments) { ['domain', 'configure', '-n', 'domain1'] }
+      it("should succeed"){ expect { run }.to exit_with_code(0) }
+      it("should display the domain config"){ run_output.should match(/Domain domain1 configuration/m) }
+      it("should not display the domain config without gear sizes"){ run_output.should_not match(/Allowed Gear Sizes/) }
+
+      context "server supports allowed gear sizes" do
+        before{ rest_client.domains.first.should_receive(:allowed_gear_sizes).and_return([]) }
+        it("should display the domain config"){ run_output.should match(/Domain domain1 configuration.*Allowed Gear Sizes:\s+<none>/m) }
+      end
+      context "server supports allowed gear sizes" do
+        before{ rest_client.domains.first.should_receive(:allowed_gear_sizes).and_return(['small', 'medium']) }
+        it("should display the domain config"){ run_output.should match(/Domain domain1 configuration.*Allowed Gear Sizes:\s+small, medium/m) }
+      end
+    end
+
+    context "when server does not support allowed-gear-sizes" do
+      before do
+        rest_client.add_domain("domain1")
+        rest_client.api.should_receive(:has_param?).with(:add_domain, 'allowed_gear_sizes').and_return(false)
+      end
+      let(:arguments) { ['domain', 'configure', '--allowed-gear-sizes', 'small'] }
+      it("display a message"){ run_output.should match 'The server does not support --allowed-gear-sizes' }
+    end
+
+    context "against a server that supports gear sizes" do
+      let(:username){ 'test_user' }
+      let(:password){ 'password' }
+      let(:server){ 'test.domain.com' }
+      let(:supports_allowed_gear_sizes?){ true }
+      before{ subject.class.any_instance.stub(:namespace_context).and_return('domain1') }
+      before do
+        stub_api
+        challenge{ stub_one_domain('domain1', nil, mock_user_auth) }
+      end
+
+      context "with --allowed-gear-sizes singular" do
+        before do
+          stub_api_request(:put, "domains/domain1/update", nil).
+            with(:body => {:allowed_gear_sizes => ['valid']}).
+            to_return({:body => {:type => 'domain', :data => {:name => 'domain1', :allowed_gear_sizes => ['valid']}, :messages => [{:severity => 'info', :text => 'Updated allowed gear sizes'},]}.to_json, :status => 200})
+        end
+        let(:arguments) { ['domain', 'configure', '--trace', '--allowed-gear-sizes', 'valid'] }
+      it("should succeed"){ expect { run }.to exit_with_code(0) }
+      it("should display the domain config"){ run_output.should match(/Domain domain1 configuration.*Allowed Gear Sizes:\s+valid/m) }
+      end
+
+      context "with --allowed-gear-sizes multiple" do
+        before do
+          stub_api_request(:put, "domains/domain1/update", nil).
+            with(:body => {:allowed_gear_sizes => ['one', 'two']}).
+            to_return({:body => {:type => 'domain', :data => {:name => 'domain1', :allowed_gear_sizes => ['one', 'two']}, :messages => [{:severity => 'info', :text => 'Updated allowed gear sizes'},]}.to_json, :status => 200})
+        end
+        let(:arguments) { ['domain', 'configure', '--trace', '--allowed-gear-sizes', 'one,two'] }
+        it("should succeed"){ expect { run }.to exit_with_code(0) }
+        it("should display the domain config"){ run_output.should match(/Domain domain1 configuration.*Allowed Gear Sizes:\s+one, two/m) }
+      end
+
+      context "with --allowed-gear-sizes" do
+        let(:arguments) { ['domain', 'configure', 'domain1', '--trace', '--allowed-gear-sizes'] }
+        it("raise an invalid option"){ expect{ run }.to raise_error(OptionParser::InvalidOption, /Provide a comma delimited list of valid gear/) }
+      end
+
+      context "with --allowed-gear-sizes=false" do
+        before do
+          stub_api_request(:put, "domains/domain1/update", nil).
+            with(:body => {:allowed_gear_sizes => ['false']}).
+            to_return({:body => {:type => 'domain', :messages => [{:field => 'allowed_gear_sizes', :exit_code => 10, :severity => 'error', :text => 'The specified gear size is invalid: false'},]}.to_json, :status => 422})
+        end
+        let(:arguments) { ['domain', 'configure', '--allowed-gear-sizes=false'] }
+        it("should succeed"){ expect { run }.to exit_with_code(1) }
+        it("should display the domain config"){ run_output.should match(/Updating domain configuration.*The specified gear size is invalid/m) }
+      end
+
+      context "with --no-allowed-gear-sizes" do
+        before do
+          stub_api_request(:put, "domains/domain1/update", nil).
+            with(:body => {:allowed_gear_sizes => []}).
+            to_return({:body => {:type => 'domain', :data => {:name => 'domain1', :allowed_gear_sizes => []}, :messages => [{:severity => 'info', :text => 'Updated allowed gear sizes'},]}.to_json, :status => 200})
+        end
+        let(:arguments) { ['domain', 'configure', '--no-allowed-gear-sizes'] }
+        it("should succeed"){ expect { run }.to exit_with_code(0) }
+        it("should display the domain config"){ run_output.should match(/Domain domain1 configuration.*Allowed Gear Sizes:\s+<none>/m) }
+      end
+    end
+  end
+
+  describe 'leave' do
+    before{ rest_client.add_domain("deleteme") }
+    let(:arguments) { ['domain', 'leave', '-n', 'deleteme'] }
+
+    it "should leave the domain" do
+      rest_client.domains.first.should_receive(:leave)
+      expect { run }.to exit_with_code(0)
+    end
+  end
+
+  describe 'delete' do
+    before{ rest_client }
+    let(:arguments) { ['domain', 'delete', 'deleteme'] }
+
+    context 'when no issues with ' do
+      before{ rest_client.add_domain("deleteme") }
+
+      it "should delete a domain" do
+        expect { run }.to exit_with_code(0)
+        rest_client.domains.empty?.should be_true
+      end
+    end
+
+    context 'when there is a different domain' do
+      before{ rest_client.add_domain("dontdelete") }
+
+      it "should error out" do
+        expect { run }.to exit_with_code(127)
+        rest_client.domains[0].name.should == 'dontdelete'
+      end
+      it { run_output.should match("Domain deleteme not found") }
+    end
+
+    context 'when there are applications on the domain' do
+      before do
+        domain = rest_client.add_domain("deleteme")
+        domain.add_application 'testapp1', 'mock-1.0'
+      end
+      it "should error out" do
+        expect { run }.to exit_with_code(1)
+        rest_client.domains[0].name.should == 'deleteme'
+      end
+      it { run_output.should match("Applications must be empty") }
+    end
+  end
+
+  describe 'help' do
+    let(:arguments) { ['domain', '--help'] }
+
+    context 'help is run' do
+      it "should display help" do
+        expect { run }.to exit_with_code(0)
+      end
+      it('should output usage') { run_output.should match("Usage: pbox domain") }
+    end
+  end
+end