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

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

@@ -1,277 +0,0 @@
-require "thread"
-
-class FakeTTY
-  attr_accessor :event
-
-  def initialize
-    @input = Queue.new
-  end
-
-  def getc
-    @input.pop
-  end
-
-  def fake(input)
-    return if @input.nil?
-
-    input.each_char do |c|
-      @input << c
-    end
-  end
-
-  def close
-    @input = nil
-  end
-
-  def tty?
-    true
-  end
-end
-
-class EventLog
-  attr_accessor :process
-  attr_reader :events, :interaction, :inputs
-
-  def initialize(input)
-    @input = input
-
-    @queue = Queue.new
-    @events = []
-    @inputs = {}
-  end
-
-  def finish_input
-    @input.close
-  end
-
-  def kill_process
-    @process.kill
-    @process.join
-  end
-
-  def next_event
-    if @queue.empty?
-      if @process.status == false
-        raise "Expected more events, but the process has finished."
-      elsif @process.status == nil
-        begin
-          @process.join
-        rescue => e
-          raise "Expected more events, but process has thrown an exception: #{e}."
-        end
-      end
-    end
-
-    val = @queue.pop
-    @events << val
-    val
-  end
-
-  def pending_events
-    events = []
-
-    until @queue.empty?
-      events << @queue.pop
-    end
-
-    events
-  end
-
-  def wait_for_event(type)
-    val = next_event
-
-    until val.is_a?(type)
-      if val.important?
-        raise "Tried to skip important event while waiting for a #{type}: #{val}"
-      end
-
-      val = next_event
-    end
-
-    val
-  end
-
-
-  def pick_random_option
-    options = @interaction.options
-    choices = options[:choices]
-    chosen = choices[rand(choices.size)]
-
-    if display = options[:display]
-      provide("#{display.call(chosen)}\n")
-    else
-      provide("#{chosen}\n")
-    end
-
-    chosen
-  end
-
-  def provide(input)
-    @input.fake(input)
-  end
-
-
-  def printed(line)
-    @queue << Printed.new(line)
-  end
-
-  def asking(message, options = {})
-    @interaction = Asked.new(message, options)
-    @queue << @interaction
-  end
-
-  def got_input(name, val)
-    @inputs[name] = val
-    @queue << GotInput.new(name, val)
-  end
-
-  def raised(exception)
-    @queue << Raised.new(exception)
-  end
-
-  def did(message)
-    @queue << Did.new(message)
-  end
-
-  def skipped(message)
-    @queue << Skipped.new(message)
-  end
-
-  def failed_to(message)
-    @queue << FailedTo.new(message)
-  end
-
-  def gave_up(message)
-    @queue << GaveUp.new(message)
-  end
-
-
-  class Event
-    def important?
-      true
-    end
-  end
-
-  class Printed < Event
-    attr_reader :line
-
-    def initialize(line)
-      @line = line
-    end
-
-    def to_s
-      "<Printed '#@line'>"
-    end
-  end
-
-  class Asked < Event
-    attr_reader :message, :options
-
-    def initialize(message, options = {})
-      @message = message
-      @options = options
-    end
-
-    def to_s
-      "<Asked '#@message'>"
-    end
-  end
-
-  class GotInput < Event
-    attr_reader :name, :value
-
-    def initialize(name, value)
-      @name = name
-      @value = value
-    end
-
-    def to_s
-      "<GotInput #@name '#@value'>"
-    end
-
-    def important?
-      false
-    end
-  end
-
-  class Raised < Event
-    attr_reader :exception
-
-    def initialize(exception)
-      @exception = exception
-    end
-
-    def to_s
-      "<Raised #{@exception.class} '#@exception'>"
-    end
-  end
-
-  class Progress < Event
-    attr_reader :message
-
-    def initialize(message)
-      @message = message
-    end
-
-    def ==(other)
-      other.is_a?(self.class) &&
-        @message == other.message
-    end
-  end
-
-  class Did < Progress
-    def to_s
-      "<Did '#@message'>"
-    end
-
-    def report
-      "do '#@message'"
-    end
-
-    def report_past
-      "did '#@message'"
-    end
-  end
-
-  class Skipped < Progress
-    def to_s
-      "<Skipped '#@message'>"
-    end
-
-    def report
-      "skip '#@message'"
-    end
-
-    def report_past
-      "skipped '#@message'"
-    end
-  end
-
-  class FailedTo < Progress
-    def to_s
-      "<FailedTo '#@message'>"
-    end
-
-    def report
-      "fail to '#@message'"
-    end
-
-    def report_past
-      "failed to '#@message'"
-    end
-  end
-
-  class GaveUp < Progress
-    def to_s
-      "<GaveUp '#@message'>"
-    end
-
-    def report
-      "give up on '#@message'"
-    end
-
-    def report_past
-      "gave up on '#@message'"
-    end
-  end
-end

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

@@ -1,94 +0,0 @@
-require "mothership"
-require "interact"
-require "vmc"
-
-# [EventLog]
-$vmc_event = nil
-
-class VMC::CLI
-  def run(name)
-    if input[:help]
-      invoke :help, :command => cmd.name.to_s
-    else
-      precondition
-      super
-    end
-  end
-
-  class ProgressEventReporter
-    def initialize(message, skipper)
-      @message = message
-      @skipper = skipper
-      @skipped = false
-    end
-
-    def skip(&blk)
-      @skipped = true
-      $vmc_event.skipped(@message)
-      @skipper.skip(&blk)
-    end
-
-    def fail(&blk)
-      @skipped = true
-      $vmc_event.failed_to(@message)
-      @skipper.fail(&blk)
-    end
-
-    def give_up(&blk)
-      @skipped = true
-      $vmc_event.gave_up(@message)
-      @skipper.give_up(&blk)
-    end
-
-    def skipped?
-      @skipped
-    end
-  end
-
-  def ask(*args)
-    $vmc_event.asking(*args) if $vmc_event
-    super
-  end
-
-  def line(*args)
-    $vmc_event.printed(*args) if $vmc_event
-    super
-  end
-
-  def force?
-    false
-  end
-
-  def with_progress(msg, &blk)
-    super(msg) do |s|
-      reporter = ProgressEventReporter.new(msg, s)
-
-      res = blk.call(reporter)
-
-      $vmc_event.did(msg) unless reporter.skipped?
-
-      res
-    end
-  rescue
-    $vmc_event.failed_to(msg)
-    raise
-  end
-end
-
-class Mothership::Inputs
-  alias_method :vmc_spec_get, :get
-
-  def get(name, context, *args)
-    val = vmc_spec_get(name, context, *args)
-    $vmc_event.got_input(name, val) if $vmc_event
-    val
-  end
-end
-
-module Interactive
-  def set_input_state(input)
-  end
-
-  def restore_input_state(input, before)
-  end
-end

data/vmc-ng/spec/Rakefile

@@ -1,13 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-Bundler.require(:default, :development)
-
-require 'rake/dsl_definition'
-require 'rake'
-require 'rspec'
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new do |t|
-  t.pattern = "**/*_spec.rb"
-  t.rspec_opts = ["--format", "documentation", "--colour"]
-end

data/vmc-ng/spec/app/app_spec.rb

@@ -1,19 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-describe "App#app" do
-  it "shows the app name if it exists" do
-    with_random_app do |app|
-      running(:app, {}, :app => app.name) do
-        outputs(app.name)
-      end
-    end
-  end
-
-  it "fails if an unknown app is provided" do
-    running(:app, {}, :app => "unknown-app") do
-      raises(VMC::UserError) do |e|
-        e.message.should == "Unknown app 'unknown-app'"
-      end
-    end
-  end
-end

data/vmc-ng/spec/app/apps_spec.rb

@@ -1,79 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-describe "App#apps" do
-  it "lists app names" do
-    with_random_apps do |apps|
-      running(:apps) do
-        does("Getting applications in #{client.current_space.name}")
-
-        apps.sort_by(&:name).each do |a|
-          outputs(a.name)
-        end
-      end
-    end
-  end
-
-  it "filters by name with --name" do
-    with_random_apps do |apps|
-      name = sample(apps).name
-
-      running(:apps, :name => name) do
-        does("Getting applications in #{client.current_space.name}")
-
-        apps.sort_by(&:name).each do |a|
-          if a.name == name
-            outputs(a.name)
-          end
-        end
-      end
-    end
-  end
-
-  it "filters by runtime with --runtime" do
-    with_random_apps do |apps|
-      runtime = sample(apps).runtime
-
-      running(:apps, :runtime => runtime.name) do
-        does("Getting applications in #{client.current_space.name}")
-
-        apps.sort_by(&:name).each do |a|
-          if a.runtime =~ /#{runtime}/
-            outputs(a.name)
-          end
-        end
-      end
-    end
-  end
-
-  it "filters by framework with --framework" do
-    with_random_apps do |apps|
-      framework = sample(apps).framework
-
-      running(:apps, :framework => framework.name) do
-        does("Getting applications in #{client.current_space.name}")
-
-        apps.sort_by(&:name).each do |a|
-          if a.framework == framework
-            outputs(a.name)
-          end
-        end
-      end
-    end
-  end
-
-  it "can be told which space with --space" do
-    with_new_space do |space|
-      with_random_apps do |other_apps|
-        with_random_apps(space) do |apps|
-          running(:apps, :space => space) do
-            does("Getting applications in #{space.name}")
-
-            apps.sort_by(&:name).each do |a|
-              outputs(a.name)
-            end
-          end
-        end
-      end
-    end
-  end
-end