vmc 0.5.0.beta.7 → 0.5.0.beta.10

data/lib/vmc/cli/domain/add_domain.rb

@@ -1,25 +0,0 @@
-require "vmc/cli/domain/base"
-
-module VMC::Domain
-  class AddDomain < Base
-    desc "Add a domain to a space"
-    group :domains
-    input :name, :desc => "Domain to add", :argument => :required
-    input :space, :desc => "Space to add the domain to",
-          :default => proc { client.current_space },
-          :from_given => by_name(:space)
-    def add_domain
-      space = input[:space]
-      name = input[:name].sub(/^\*\./, "")
-
-      org = space.organization
-
-      domain = org.domains.find { |d| d.name == name } ||
-        invoke(:create_domain, :org => org, :name => name)
-
-      with_progress("Adding #{c(domain.name, :name)} to #{c(space.name, :name)}") do
-        space.add_domain(domain)
-      end
-    end
-  end
-end

data/lib/vmc/cli/domain/create_domain.rb

@@ -1,28 +0,0 @@
-require "vmc/cli/domain/base"
-
-module VMC::Domain
-  class CreateDomain < Base
-    desc "Create a domain"
-    group :domains
-    input :name, :desc => "Domain name to create", :argument => :required
-    input :organization, :desc => "Organization to add the domain to",
-          :aliases => %w{--org -o},
-          :default => proc { client.current_organization },
-          :from_given => by_name(:organization)
-    input :shared, :desc => "Create a shared domain", :default => false
-    def create_domain
-      org = input[:organization]
-      name = input[:name].sub(/^\*\./, "")
-
-      domain = client.domain
-      domain.name = name
-      domain.owning_organization = org unless input[:shared]
-
-      with_progress("Creating domain #{c(name, :name)}") do
-        domain.create!
-      end
-
-      domain
-    end
-  end
-end

data/lib/vmc/cli/domain/delete_domain.rb

@@ -1,56 +0,0 @@
-require "vmc/cli/domain/base"
-
-module VMC::Domain
-  class DeleteDomain < Base
-    # TODO: refactor; using find_by_name, and target cycling between
-    # org/client, is awkward
-
-    desc "Delete a domain"
-    group :domains
-    input :domain, :desc => "URL to map to the application",
-          :argument => :optional, :from_given => find_by_name("domain")
-    input :organization, :desc => "Organization to delete the domain from",
-          :aliases => %w{--org -o}, :from_given => by_name(:organization)
-    input :all, :desc => "Delete all domains", :default => false
-    input :really, :type => :boolean, :forget => true, :hidden => true,
-          :default => proc { force? || interact }
-    def delete_domain
-      target = input[:organization] || client
-
-      if input[:all]
-        return unless input[:really, "ALL DOMAINS", :bad]
-
-        target.domains.each do |r|
-          begin
-            invoke :delete_domain, :domain => r, :really => true
-          rescue CFoundry::APIError => e
-            err "#{e.class}: #{e.message}"
-          end
-        end
-
-        return
-      end
-
-      domain = input[:domain, target.domains]
-
-      return unless input[:really, domain.name, :name]
-
-      with_progress("Deleting domain #{c(domain.name, :name)}") do
-        domain.delete!
-      end
-    end
-
-    private
-
-    def ask_domain(domains)
-      fail "No domains." if domains.empty?
-
-      ask "Which domain?", :choices => domains.sort_by(&:name),
-          :display => proc(&:name)
-    end
-
-    def ask_really(name, color)
-      ask("Really delete #{c(name, color)}?", :default => false)
-    end
-  end
-end

data/lib/vmc/cli/domain/remove_domain.rb

@@ -1,28 +0,0 @@
-require "vmc/cli/domain/base"
-
-module VMC::Domain
-  class RemoveDomain < Base
-    desc "Remove a domain from a space"
-    group :domains
-    input :domain, :desc => "Domain to add", :argument => :optional,
-          :from_given => by_name(:domain)
-    input :space, :desc => "Space to add the domain to",
-          :from_given => by_name(:space),
-          :default => proc { client.current_space }
-    def remove_domain
-      space = input[:space]
-      domain = input[:domain, space]
-
-      with_progress("Removing #{c(domain.name, :name)} from #{c(space.name, :name)}") do
-        space.remove_domain(domain)
-      end
-    end
-
-    private
-
-    def ask_domain(space)
-      ask "Which domain?", :choices => space.domains,
-          :display => proc(&:name)
-    end
-  end
-end

data/lib/vmc/cli/route/create_route.rb

@@ -1,49 +0,0 @@
-require "vmc/cli/route/base"
-
-module VMC::Route
-  class CreateRoute < Base
-    desc "Create a route"
-    group :routes
-    input :url, :desc => "Full route in URL form", :argument => :optional
-    input :host, :desc => "Host name"
-    input :domain, :desc => "Domain to add the route to",
-          :from_given => by_name(:domain)
-    def create_route
-      if url = input[:url]
-        host, domain_name = url.split(".", 2)
-        return invoke :create_route, {}, :host => host, :domain => domain_name
-      end
-
-      domain = input[:domain]
-      host = input[:host]
-
-      route = client.route
-      route.host = host
-      route.domain = domain
-      route.space = client.current_space
-
-      with_progress("Creating route #{c("#{host}.#{domain.name}", :name)}") do
-        route.create!
-      end
-    rescue CFoundry::RouteHostTaken => e
-      line c(e.description, :error)
-      line
-      input.forget(:host)
-      retry
-    end
-
-    private
-
-    def ask_host
-      ask("Host name?")
-    end
-
-    def ask_domain
-      domains = client.current_organization.domains
-      fail "No domains!" if domains.empty?
-
-      ask "Which domain?", :choices => domains,
-          :display => proc(&:name)
-    end
-  end
-end

data/lib/vmc/cli/route/delete.rb

@@ -1,47 +0,0 @@
-require "vmc/cli/route/base"
-
-module VMC::Route
-  class Delete < Base
-    desc "Delete a route"
-    group :routes
-    input :route, :desc => "Route to delete", :argument => :optional,
-          :from_given => find_by_name("route") { client.routes },
-          :default => proc { force? || interact }
-    input :all, :desc => "Delete all routes", :default => false
-    input :really, :type => :boolean, :forget => true, :hidden => true,
-          :default => proc { force? || interact }
-    def delete_route
-      if input[:all]
-        return unless input[:really, "ALL ROUTES", :bad]
-
-        client.routes.each do |r|
-          invoke :delete_route, :route => r, :really => true
-        end
-
-        return
-      end
-
-      route = input[:route]
-
-      return unless input[:really, route.name, :name]
-
-      with_progress("Deleting route #{c(route.name, :name)}") do
-        route.delete!
-      end
-    end
-
-    private
-
-    def ask_route
-      routes = client.routes
-      fail "No routes." if routes.empty?
-
-      ask "Which route?", :choices => routes.sort_by(&:name),
-        :display => proc(&:name)
-    end
-
-    def ask_really(name, color)
-      ask("Really delete #{c(name, color)}?", :default => false)
-    end
-  end
-end

data/spec/support/feature_helpers.rb

@@ -1,16 +0,0 @@
-def vmc_ok(argv)
-  with_output_to do |out|
-    Mothership.new.exit_status 0
-    code = VMC::CLI.start(argv + ["--no-script"])
-    yield out.string.strip_progress_dots if block_given?
-    expect(code).to eq 0
-  end
-end
-
-def vmc_fail(argv)
-  with_output_to do |out|
-    code = VMC::CLI.start(argv + ["--no-script"])
-    yield out.string.strip_progress_dots if block_given?
-    expect(code).to eq 1
-  end
-end

data/spec/support/interact_helpers.rb

@@ -1,27 +0,0 @@
-def stub_ask(*args, &block)
-  a_stub = nil
-  any_instance_of VMC::CLI do |interactive|
-    a_stub = stub(interactive).ask(*args, &block)
-  end
-  a_stub
-end
-
-def mock_ask(*args, &block)
-  a_mock = nil
-  any_instance_of VMC::CLI do |interactive|
-    a_mock = mock(interactive).ask(*args, &block)
-  end
-  a_mock
-end
-
-def dont_allow_ask(*args)
-  any_instance_of VMC::CLI do |interactive|
-    dont_allow(interactive).ask(*args)
-  end
-end
-
-def mock_with_progress(message)
-  any_instance_of VMC::CLI do |interactive|
-    mock(interactive).with_progress(message) { |_, block| block.call }
-  end
-end

data/spec/vmc/cli/route/delete_route_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-require "vmc/cli/route/delete"
-
-describe VMC::Route::Delete do
-  let(:global) { { :color => false, :quiet => true } }
-  let(:inputs) { {} }
-  let(:given) { {} }
-  let(:client) { fake_client }
-
-  before do
-    any_instance_of(VMC::CLI) do |cli|
-      stub(cli).client { client }
-      stub(cli).precondition { nil }
-    end
-  end
-
-  subject { Mothership.new.invoke(:delete_route, inputs, given, global) }
-
-  describe 'metadata' do
-    let(:command) { Mothership.commands[:delete_route] }
-
-    describe 'command' do
-      subject { command }
-      its(:description) { should eq "Delete a route" }
-      it { expect(Mothership::Help.group(:routes)).to include(subject) }
-    end
-
-    include_examples 'inputs must have descriptions'
-
-    describe 'inputs' do
-      subject { command.inputs }
-      it { expect(subject[:route][:description]).to eq "Route to delete" }
-      it { expect(subject[:really][:hidden]).to be_true }
-      it { expect(subject[:all][:description]).to eq "Delete all routes" }
-    end
-
-    describe 'arguments' do
-      subject { command.arguments }
-      it 'has the correct argument order' do
-        should eq([
-          { :type => :optional, :value => nil, :name => :route }
-        ])
-      end
-    end
-  end
-
-  context 'when there are no routes' do
-    context 'and a name is given' do
-      let(:given) { { :route => "some-route" } }
-      it { expect { subject }.to raise_error(VMC::UserError, "Unknown route 'some-route'.") }
-    end
-
-    context 'and a name is not given' do
-      it { expect { subject }.to raise_error(VMC::UserError, "No routes.") }
-    end
-  end
-
-  context "when there are routes" do
-    let(:client) { fake_client(:routes => routes) }
-    let(:routes) { fake_list(:route, 2) }
-    let(:deleted_route) { routes.first }
-
-    context 'when the defaults are used' do
-      it 'asks for the route and confirmation' do
-        mock_ask('Which route?', anything) { deleted_route }
-        mock_ask("Really delete #{deleted_route.name}?", :default => false) { true }
-        stub(deleted_route).delete!
-        subject
-      end
-
-      it 'does not try to delete all routes' do
-        stub_ask("Which route?", anything) { deleted_route }
-        stub_ask(/Really delete/, anything) { true }
-        mock(deleted_route).delete!
-        dont_allow(routes.last).delete!
-        subject
-      end
-    end
-
-    context 'when the route is inputted' do
-      let(:inputs) { { :route => deleted_route } }
-
-      it 'does not ask which route but still asks for confirmation' do
-        dont_allow_ask('Which route?', anything)
-        mock_ask("Really delete #{deleted_route.name}?", :default => false) { true }
-        stub(deleted_route).delete!
-        subject
-      end
-
-      it 'deletes the route' do
-        dont_allow_ask("Which route?", anything)
-        stub_ask(/Really delete/, anything) { true }
-        mock(deleted_route).delete!
-        subject
-      end
-    end
-
-    context 'when the all flag is provided' do
-      let(:inputs) { { :all => true } }
-
-      it 'deletes the route' do
-        stub_ask { true }
-        routes.each do |route|
-          mock(route).delete!
-        end
-        subject
-      end
-
-      it 'asks to delete the routes' do
-        mock_ask("Really delete ALL ROUTES?", :default => false) { true }
-        dont_allow_ask('Which route?', anything)
-        routes.each do |route|
-          stub(route).delete!
-        end
-        subject
-      end
-
-      context 'and also with the really flag' do
-        let(:inputs) { { :all => true, :really => true } }
-
-        it 'does not ask' do
-          dont_allow_ask("Really delete ALL ROUTES?", :default => false)
-          routes.each do |route|
-            stub(route).delete!
-          end
-          subject
-        end
-      end
-    end
-
-    context 'when the really flag is provided' do
-      context 'when no route given' do
-        let(:inputs) { { :really => true } }
-
-        it 'asks for the route, and does not confirm deletion' do
-          dont_allow_ask("Really delete ALL ROUTES?", :default => false)
-          mock_ask('Which route?', anything) { deleted_route }
-          mock(deleted_route).delete!
-          subject
-        end
-      end
-
-      context 'when a route is given' do
-        let(:inputs) { { :route => deleted_route, :really => true } }
-
-        it 'asks for the route, and does not confirm deletion' do
-          dont_allow_ask("Really delete ALL ROUTES?", :default => false)
-          dont_allow_ask('Which route?', anything)
-          mock(deleted_route).delete!
-          subject
-        end
-
-        it 'displays the progress' do
-          mock_with_progress("Deleting route #{deleted_route.name}")
-          mock(deleted_route).delete!
-
-          subject
-        end
-      end
-    end
-  end
-end