vmc 0.4.0.beta.93 → 0.4.0.beta.94

data/vmc-ng/lib/vmc/cli/domain.rb

@@ -1,164 +0,0 @@
-require "vmc/cli"
-
-module VMC
-  class Domain < CLI
-    def precondition
-      super
-      fail "This command is v2-only." unless v2?
-    end
-
-
-    desc "List domains in a space"
-    group :domains
-    input :space, :argument => :optional,
-      :default => proc { client.current_space },
-      :from_given => by_name("space"),
-      :desc => "Space to list the domains from"
-    input :all, :type => :boolean, :default => false,
-      :desc => "List all domains"
-    def domains
-      space = input[:space]
-
-      domains =
-        if input[:all]
-          with_progress("Getting all domains") do
-            client.domains
-          end
-        else
-          with_progress("Getting domains in #{c(space.name, :name)}") do
-            space.domains
-          end
-        end
-
-      line unless quiet?
-
-      table(
-        %w{name owner},
-        domains.sort_by(&:name).collect { |r|
-          [ c(r.name, :name),
-            if org = r.owning_organization
-              c(org.name, :name)
-            else
-              d("none")
-            end
-          ]
-        })
-    end
-
-
-    desc "Delete a domain"
-    group :domains
-    input(:domain, :argument => :optional,
-          :from_given => find_by_name("domain"),
-          :desc => "URL to map to the application") { |domains|
-      fail "No domains." if domains.empty?
-
-      ask "Which domain?", :choices => domains.sort_by(&:name),
-        :display => proc(&:name)
-    }
-    input :organization, :aliases => ["--org", "-o"],
-      :from_given => by_name("organization"),
-      :desc => "Organization to delete the domain from"
-    input(:really, :type => :boolean, :forget => true,
-          :default => proc { force? || interact }) { |name, color|
-      ask("Really delete #{c(name, color)}?", :default => false)
-    }
-    input :all, :type => :boolean, :default => false,
-      :desc => "Delete all domains"
-    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
-
-
-    desc "Create a domain"
-    group :domains
-    input :name, :argument => :required,
-      :desc => "Domain name to create"
-    input :organization, :aliases => ["--org", "-o"],
-      :from_given => by_name("organization"),
-      :default => proc { client.current_organization },
-      :desc => "Organization to add the domain to"
-    input :shared, :type => :boolean, :default => false,
-      :desc => "Create a shared domain (admin-only)"
-    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
-
-
-    desc "Add a domain to a space"
-    group :domains
-    input :name, :argument => :required,
-      :desc => "Domain to add"
-    input :space, :from_given => by_name("space"),
-      :default => proc { client.current_space },
-      :desc => "Space to add the domain to"
-    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
-
-
-    desc "Remove a domain from a space"
-    group :domains
-    input(:domain, :argument => :optional,
-          :from_given => by_name("domain"),
-          :desc => "Domain to add") { |space|
-      ask "Which domain?", :choices => space.domains,
-        :display => proc(&:name)
-    }
-    input :space, :from_given => by_name("space"),
-      :default => proc { client.current_space },
-      :desc => "Space to add the domain to"
-    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
-  end
-end

data/vmc-ng/lib/vmc/cli/route.rb

@@ -1,106 +0,0 @@
-require "vmc/cli"
-
-module VMC
-  class Route < CLI
-    def precondition
-      super
-      fail "This command is v2-only." unless v2?
-    end
-
-
-    desc "List routes in a space"
-    group :routes
-    def routes
-      # TODO: scope to space once space.routes is possible
-      routes =
-        with_progress("Getting routes") do
-          client.routes
-        end
-
-      line unless quiet?
-
-      table(
-        %w{host domain},
-        routes.sort_by { |r| "#{r.domain.name} #{r.host}" }.collect { |r|
-          [ c(r.host, :name),
-            r.domain.name
-          ]
-        })
-    end
-
-
-    desc "Delete a route"
-    group :routes
-    input(:route, :argument => :optional,
-          :from_given => find_by_name("route"),
-          :desc => "URL to map to the application") { |routes|
-      ask "Which route?", :choices => routes.sort_by(&:name),
-        :display => proc(&:name)
-    }
-    input(:really, :type => :boolean, :forget => true,
-          :default => proc { force? || interact }) { |name, color|
-      ask("Really delete #{c(name, color)}?", :default => false)
-    }
-    input :all, :type => :boolean, :default => false,
-      :desc => "Delete all routes"
-    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
-
-      routes = client.routes
-      fail "No routes." if routes.empty?
-
-      route = input[:route, client.routes]
-
-      return unless input[:really, route.name, :name]
-
-      with_progress("Deleting route #{c(route.name, :name)}") do
-        route.delete!
-      end
-    end
-
-
-    desc "Create a route"
-    group :routes
-    input :url, :argument => :optional,
-      :desc => "Full route in URL form"
-    input(:host, :desc => "Host name") {
-      ask "Host name?"
-    }
-    input(:domain, :desc => "Domain to add the route to",
-          :from_given => find_by_name("domain")) { |domains|
-      ask "Which domain?", :choices => domains,
-        :display => proc(&:name)
-    }
-    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, client.current_organization.domains]
-      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
-  end
-end

data/vmc-ng/lib/vmc/spec_helpers.rb

@@ -1,431 +0,0 @@
-require "rspec"
-
-require "cfoundry"
-require "vmc"
-
-require "vmc/spec_helpers/eventlog"
-require "vmc/spec_helpers/patches"
-
-
-module VMCHelpers
-  TARGET = ENV["VMC_TEST_TARGET"] || "http://localhost:8181"
-  USER = ENV["VMC_TEST_USER"] || "sre@vmware.com"
-  PASSWORD = ENV["VMC_TEST_PASSWORD"] || "test"
-
-  def random_str
-    format("%x", rand(1000000))
-  end
-
-  def client
-    VMC::CLI.client
-  end
-
-  # invoke a block while logged out
-  def without_auth
-    proxy = client.proxy
-    client.logout
-    client.proxy = nil
-    yield
-  ensure
-    client.login(USER, PASSWORD)
-    client.proxy = proxy
-  end
-
-  # same as Ruby 1.9's Array#sample
-  def sample(ary)
-    ary[rand(ary.size)]
-  end
-
-  # cache frameworks for app generation
-  def frameworks
-    @@frameworks ||= client.frameworks(:depth => 0)
-  end
-
-  # cache runtimes for app generation
-  def runtimes
-    @@runtimes ||= client.runtimes(:depth => 0)
-  end
-
-  def with_random_app(space = client.current_space)
-    with_random_apps(space, 1) do |apps|
-      yield apps.first
-    end
-  end
-
-  # create 2-5 random apps, call the block, and then delete them
-  def with_random_apps(space = client.current_space, num = rand(3) + 2)
-    apps = []
-
-    num.times do |n|
-      app = client.app
-      app.name = "app-#{n + 1}-#{random_str}"
-      app.space = space
-      app.instances = rand(2)
-
-      app.framework = sample(frameworks)
-      app.runtime = sample(runtimes)
-      app.memory = sample([64, 128, 256, 512])
-      app.create!
-
-      apps << app
-    end
-
-    yield apps
-  ensure
-    apps.each(&:delete!)
-  end
-
-  def with_new_space(org = client.current_organization)
-    space = client.space
-    space.name = "space-#{random_str}"
-    space.organization = org
-    space.create!
-
-    yield space
-  ensure
-    space.delete!
-  end
-
-  def running(command, inputs = {}, given = {})
-    VMC::CLI.new.exit_status 0
-
-    before_in = $stdin
-    before_out = $stdout
-    before_err = $stderr
-    before_event = $vmc_event
-
-    tty = FakeTTY.new
-
-    $vmc_event = EventLog.new(tty)
-
-    $stdin = tty
-    $stdout = StringIO.new
-    $stderr = StringIO.new
-
-    main = Thread.current
-
-    thd_group = ThreadGroup.new
-    thd = Thread.new do
-      begin
-        VMC::CLI.new.invoke(command, inputs, given, :quiet => true)
-      rescue SystemExit => e
-        unless e.status == 0
-          raise <<EOF
-execution failed with status #{e.status}!
-
-stdout:
-#{$stdout.string}
-
-stderr:
-#{$stderr.string}
-EOF
-        end
-      rescue => e
-        $vmc_event.raised(e)
-      end
-    end
-
-    thd_group.add(thd)
-
-    begin
-      $vmc_event.process = thd
-
-      yield $vmc_event
-
-      $vmc_event.should complete
-    ensure
-      thd_group.list.each(&:kill)
-    end
-  ensure
-    $stdin = before_in
-    $stdout = before_out
-    $stderr = before_err
-    $vmc_event = before_event
-  end
-end
-
-module VMCMatchers
-  class Contain
-    def initialize(content)
-      @content = content
-    end
-
-    def matches?(actual)
-      @actual = actual
-      true
-    end
-
-    def failure_message
-      "expected '#@content' to be in the output"
-    end
-
-    def negative_failure_message
-      "expected '#@content' to NOT be in the output"
-    end
-  end
-
-  def contain(content)
-    Contain.new(content)
-  end
-
-  class Ask
-    def initialize(message)
-      @message = message
-    end
-
-    def matches?(log)
-      ev = log.wait_for_event(EventLog::Asked)
-
-      @actual = ev.message
-      @actual == @message
-    end
-
-    def failure_message
-      "expected to be asked '#@message', got '#@actual'"
-    end
-
-    def negative_failure_message
-      "expected to NOT be asked for #@message"
-    end
-  end
-
-  def ask(message)
-    Ask.new(message)
-  end
-
-  class HaveInput
-    def initialize(name, value = nil)
-      @name = name
-      @expected = value
-    end
-
-    def matches?(log)
-      input = log.wait_for_event(EventLog::GotInput)
-      until input.name == @name
-        input = log.wait_for_event(EventLog::GotInput)
-      end
-
-      @actual = input.value
-      @actual == @expected
-    end
-
-    def failure_message
-      "expected to have input '#@name' as '#@expected', but got '#@actual'"
-    end
-
-    def negative_failure_message
-      "expected not to have input '#@name', but had it as '#@actual'"
-    end
-  end
-
-  def have_input(name, value = nil)
-    HaveInput.new(name, value)
-  end
-
-  class Output
-    def initialize(line)
-      @expected = line
-    end
-
-    def matches?(log)
-      @actual = log.wait_for_event(EventLog::Printed).line
-      @actual == @expected
-    end
-
-    def failure_message
-      "expected '#@expected' to be in the output, but got '#@actual'"
-    end
-
-    def negative_failure_message
-      "expected '#@expected' NOT to be in the output, but it was"
-    end
-  end
-
-  def output(line)
-    Output.new(line)
-  end
-
-  class Complete
-    def matches?(log)
-      @log = log
-
-      log.process.join(1)
-
-      log.process.status == false
-    end
-
-    def failure_message
-      pending = @log.pending_events
-
-      if @exception
-        "process existed with an exception: #@exception"
-      elsif !pending.empty?
-        "expected process to complete, but it's pending events #{pending}"
-      else
-        "process is blocked; status: #{@log.process.status}"
-      end
-    end
-
-    def negative_failure_message
-      "expected process to still be running, but it's completed"
-    end
-  end
-
-  def complete
-    Complete.new
-  end
-
-
-  class FailWith
-    def initialize(exception, predicate = nil)
-      @expected = exception
-      @predicate = predicate
-    end
-
-    def matches?(log)
-      @actual = log.wait_for_event(EventLog::Raised).exception
-
-      return false unless @actual.is_a?(@expected)
-
-      @predicate.call(@actual) if @predicate
-
-      true
-    end
-
-    def failure_message
-      "expected #@expected to be raised, but got #{@actual.class}: '#@actual'"
-    end
-
-    def negative_failure_message
-      "expected #@expected to NOT be raised, but it was"
-    end
-  end
-
-  def fail_with(exception, &blk)
-    FailWith.new(exception, blk)
-  end
-
-
-  class ProgressExpectation
-    def matches?(log)
-      @actual = log.wait_for_event(EventLog::Progress)
-      @actual == @expected
-    end
-
-    def failure_message
-      "expected to #{@expected.report}, but #{@actual.report_past} instead"
-    end
-
-    def negative_failure_message
-      "expected not to #{@expected.report}"
-    end
-  end
-
-  class Successfully < ProgressExpectation
-    def initialize(message)
-      @expected = EventLog::Did.new(message)
-    end
-  end
-
-  class Skip < ProgressExpectation
-    def initialize(message)
-      @expected = EventLog::Skipped.new(message)
-    end
-  end
-
-  class FailTo < ProgressExpectation
-    def initialize(message)
-      @expected = EventLog::FailedTo.new(message)
-    end
-  end
-
-  class GiveUp < ProgressExpectation
-    def initialize(message)
-      @expected = EventLog::GaveUp.new(message)
-    end
-  end
-
-  def successfully(message)
-    Successfully.new(message)
-  end
-
-  def skip(message)
-    Skip.new(message)
-  end
-
-  def fail_to(message)
-    FailTo.new(message)
-  end
-
-  def give_up(message)
-    GiveUp.new(message)
-  end
-
-
-  def asks(what)
-    $vmc_event.should ask(what)
-  end
-
-  def given(what)
-    $vmc_event.provide("#{what}\n")
-  end
-
-  def has_input(name, value = nil)
-    $vmc_event.should have_input(name, value)
-  end
-
-  def raises(exception, &blk)
-    $vmc_event.should fail_with(exception, &blk)
-  end
-
-  def finish
-    $vmc_event.should complete
-  end
-
-  def outputs(what)
-    $vmc_event.should output(what)
-  end
-
-  def does(what)
-    $vmc_event.should successfully(what)
-  end
-
-  def skips(what)
-    $vmc_event.should skip(what)
-  end
-
-  def fails_to(what)
-    $vmc_event.should fail_to(what)
-  end
-
-  def gives_up(what)
-    $vmc_event.should give_up(what)
-  end
-
-  def kill
-    $vmc_event.kill_process
-  end
-
-  def with_output
-    yield $vmc_event.wait_for_event(EventLog::Printed).line
-  end
-end
-
-RSpec.configure do |c|
-  c.include VMCHelpers
-  c.include VMCMatchers
-
-  c.before(:all) do
-    VMC::CLI.client = CFoundry::Client.new(VMCHelpers::TARGET)
-
-    client.login(
-      :username => VMCHelpers::USER,
-      :password => VMCHelpers::PASSWORD)
-
-    unless client.is_a? CFoundry::V1::Client
-      client.current_organization = client.organizations.first
-      client.current_space = client.current_organization.spaces.first
-    end
-  end
-end
-