cf_script 0.0.1.beta.1

data/test/lib/cf_script/scope/target_test.rb

@@ -0,0 +1,158 @@
+require 'test_helper'
+
+describe CfScript::Scope::Target do
+  include MockExecution
+
+  subject {
+    target = nil
+
+    fake_cf target: :staging do
+      target = CfScript::Scope::Target.new
+    end
+
+    target
+  }
+
+  it "sets initial_target and current_target on initialize" do
+    initial_target = subject.instance_variable_get('@initial_target')
+    current_target = subject.instance_variable_get('@current_target')
+
+    assert initial_target
+    assert current_target
+
+    assert_instance_of CfScript::Target, initial_target
+    assert_instance_of CfScript::Target, current_target
+
+    assert_equal 'staging', initial_target.space
+    assert_equal 'ACME',    initial_target.org
+
+    assert_equal 'staging', current_target.space
+    assert_equal 'ACME',    current_target.org
+  end
+
+  it "updates current_target when target is called" do
+    fake_cf target: :production do
+      assert_equal 'staging', subject.current_space
+      assert_equal 'ACME',    subject.current_org
+
+      subject.target(:production)
+      assert_equal 'production', subject.current_space
+      assert_equal 'ACME',       subject.current_org
+    end
+  end
+
+  it "resets target to initial_target if the space has changed" do
+    fake_cf target: :production do
+      subject.target(:production)
+      assert_equal 'production', subject.current_space
+      assert_equal 'ACME',       subject.current_org
+
+      subject.finalize
+      assert_equal 'staging', subject.current_space
+      assert_equal 'ACME',    subject.current_org
+    end
+  end
+
+  it "resets target to initial_target if the org has changed" do
+    fake_cf do
+      subject.target(:staging_org)
+      assert_equal 'staging', subject.current_space
+      assert_equal 'ORG',     subject.current_org
+
+      subject.finalize
+      assert_equal 'staging', subject.current_space
+      assert_equal 'ACME',    subject.current_org
+    end
+  end
+
+  it "responds to target without args and calls Command.run" do
+    assert subject.respond_to?(:target)
+
+    CfScript::Command.stub :run, :called do
+      assert_equal :called, subject.target
+    end
+  end
+
+  it "responds to target with a space name and calls Command.run if not == current" do
+    assert subject.respond_to?(:target)
+
+    assert_equal 'staging', subject.current_space
+
+    CfScript::Command.stub :run, :called do
+      assert_equal :called, subject.target(:production)
+    end
+  end
+
+  it "returns current target if it's the same as the requested target" do
+    current_target = subject.instance_variable_get('@current_target')
+
+    CfScript::Command.stub :run, :called do
+      assert_same current_target, subject.target(:staging)
+    end
+  end
+
+  it "responds to space and calls Command.run" do
+    assert subject.respond_to?(:space)
+
+    CfScript::Command.stub :run, :called do
+      assert_equal :called, subject.space(:foo)
+    end
+  end
+
+  it "responds to space with a block and calls exec_in with a Space scope" do
+    assert subject.respond_to?(:space)
+
+    arg_catcher = lambda do |scope, args, &block|
+      assert_instance_of CfScript::Scope::Space, scope
+    end
+
+    fake_cf do
+      subject.stub :exec_in, arg_catcher do
+        assert subject.space(:staging) { nil }
+      end
+    end
+  end
+
+  it "responds to app and calls Command.run" do
+    assert subject.respond_to?(:app)
+
+    CfScript::Command.stub :run, :called do
+      assert_equal :called, subject.app(:foo)
+    end
+  end
+
+  it "responds to app with a block and calls exec_in with an App scope" do
+    assert subject.respond_to?(:app)
+
+    arg_catcher = lambda do |scope, args, &block|
+      assert_instance_of CfScript::Scope::App, scope
+    end
+
+    fake_cf do
+      subject.stub :exec_in, arg_catcher do
+        assert subject.app(:worker) { nil }
+      end
+    end
+  end
+
+  it "responds to apps and calls Command.run" do
+    assert subject.respond_to?(:apps)
+
+    CfScript::Command.stub :run, :called do
+      assert_equal :called, subject.apps
+    end
+  end
+
+  it "calls apps.select! when options is not empty" do
+    assert subject.respond_to?(:apps)
+
+    apps = MiniTest::Mock.new
+    apps.expect(:select!, apps, [{ ending_with: :foo }])
+
+    CfScript::Command.stub :run, apps do
+      subject.apps(ending_with: :foo)
+    end
+
+    apps.verify
+  end
+end

data/test/lib/cf_script/scope_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+describe CfScript::Scope do
+  subject { CfScript::Scope::Base.new }
+
+  class ScopeTest < CfScript::Scope::Base
+    attr_reader :called_enter_scope
+
+    def enter_scope
+      @called_enter_scope = true
+    end
+  end
+
+  it "calls enter_scope on initialize" do
+    assert ScopeTest.new.called_enter_scope
+  end
+
+  it "responds to finalize which calls exit_scope" do
+    assert subject.respond_to?(:finalize)
+
+    subject.stub :exit_scope, 'foo' do
+      assert_equal 'foo', subject.finalize
+    end
+  end
+
+  it "responds to spec_for and calls CfScript.spec_for" do
+    assert subject.respond_to?(:spec_for)
+
+    CfScript.stub :spec_for, 'called' do
+      assert_equal 'called', subject.spec_for(:app)
+    end
+  end
+
+  it "responds to method_missing and calls Command.run" do
+    assert subject.respond_to?(:method_missing)
+
+    CfScript::Command.stub :run, 'pong' do
+      assert_equal 'pong', subject.ping
+    end
+  end
+end

data/test/lib/cf_script/utils_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+describe CfScript::Utils do
+  subject { CfScript::Utils }
+
+  it "defines a symbolize method that symbolizes a string" do
+    assert_equal :foo_bar, subject.symbolize('foo bar')
+    assert_equal :foo_bar, subject.symbolize('foo-bar')
+    assert_equal :foo_bar, subject.symbolize('foo.bar')
+  end
+
+  it "defines a symbolize_keys method that symbolizes the keys of a Hash" do
+    input  = { 'foo-bar' => 'baz' }
+    output = subject.symbolize_keys(input)
+
+    expected = { foo_bar: 'baz' }
+
+    assert_equal expected, output
+  end
+end

data/test/lib/cf_script_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+describe CfScript do
+  include MockExecution
+
+  it "defines a config method that returns the Config object" do
+    assert CfScript.respond_to? :config
+
+    config = CfScript.config
+
+    assert_instance_of CfScript::Config, config
+    assert_same CfScript.config, config
+  end
+
+  it "defines a configure method that yields the Config object" do
+    assert CfScript.respond_to? :configure
+
+    called = false
+
+    CfScript.configure do |config|
+      called = true
+
+      assert_instance_of CfScript::Config, config
+      assert_same CfScript.config, config
+    end
+
+    assert called, 'Expected configure to yield to the block'
+  end
+
+  it "defines stdout/stderr methods that return the configured IO objects" do
+    assert CfScript.respond_to? :stdout
+    assert_same CfScript.config.io.stdout, CfScript.stdout
+
+    assert CfScript.respond_to? :stderr
+    assert_same CfScript.config.io.stderr, CfScript.stderr
+  end
+
+  it "works when cf calls are nested" do
+    space_sequence = []
+
+    fake_cf do
+      cf space: :development do
+        space_sequence << current_space
+
+        cf space: :staging do
+          space_sequence << current_space
+
+          cf space: :production do
+            space_sequence << current_space
+          end
+
+          space_sequence << current_space
+        end
+
+        space_sequence << current_space
+      end
+    end
+
+    assert_equal 'development', space_sequence[0]
+    assert_equal 'staging',     space_sequence[1]
+    assert_equal 'production',  space_sequence[2]
+    assert_equal 'staging',     space_sequence[3]
+    assert_equal 'development', space_sequence[4]
+  end
+
+  it "doesn't expose private methods" do
+    refute CfScript.respond_to?(:stack_level)
+    assert CfScript.singleton_class.private_method_defined?(:stack_level)
+
+    refute CfScript.respond_to?(:print_error)
+    assert CfScript.singleton_class.private_method_defined?(:print_error)
+  end
+end

data/test/support/assertions.rb

@@ -0,0 +1,14 @@
+def assert_app_info(app_info, expected_instances)
+  assert_instance_of CfScript::AppInfo, app_info
+
+  assert_instance_of Array, app_info.instance_status
+  assert_equal expected_instances.length, app_info.instance_status.length
+
+  app_info.instance_status.each_with_index do |instance_status, index|
+    assert_instance_of CfScript::InstanceStatus, instance_status
+
+    expected_instances[index].each do |attr, value|
+      assert_equal value, instance_status.send(attr)
+    end
+  end
+end

data/test/support/helpers/config_context.rb

@@ -0,0 +1,19 @@
+class ConfigContext
+  def initialize
+    @stdout   = CfScript.config.io.stdout
+    @stderr   = CfScript.config.io.stderr
+
+    @color    = CfScript.config.ui.color
+
+    @executor = CfScript.config.runtime.executor
+  end
+
+  def reset
+    CfScript.config.io.stdout = @stdout
+    CfScript.config.io.stderr = @stderr
+
+    CfScript.config.ui.color = @color
+
+    CfScript.config.runtime.executor = @executor
+  end
+end

data/test/support/helpers/fixture_executor.rb

@@ -0,0 +1,79 @@
+class FixtureExecutor
+  COMMON_FIXTURE_PATH  = "fixtures/common"
+  COMMAND_FIXTURE_PATH = "fixtures/commands"
+
+  def initialize(command_fixtures)
+    @@fixture_cache ||= {}
+
+    @command_fixtures = command_fixtures
+  end
+
+  def execute(env, command_line)
+    data = fixture_for(command_line)
+
+    CfScript.stdout.puts if CfScript.config.runtime.trace
+
+    [
+      data['stdout'],
+      data['stderr'],
+      OpenStruct.new(
+        exitstatus: data['status']['exitstatus'],
+        success?:   data['status']['exitstatus'] == 0
+      )
+    ]
+  end
+
+  private
+
+  def fixture_for(command_line)
+    case @command_fixtures[command_line.name]
+    when :fail, :no_endpoint, :no_login
+      dir = File.join('commands', 'common')
+      key = @command_fixtures[command_line.name]
+    else
+      dir = 'commands'
+      key = fixture_key(command_line)
+    end
+
+    unless @@fixture_cache.has_key?(key)
+      @@fixture_cache[key] = load_fixture(dir, key)
+    end
+
+    @@fixture_cache[key]
+  end
+
+  def fixture_key(command_line)
+    File.join(
+      command_line.type.to_s,
+      command_line.name.to_s,
+      command_fixture(command_line).to_s
+    )
+  end
+
+  def command_fixture(command_line)
+    case command_line.name
+    when :target
+      if command_line.options[:s]
+        command_line.options[:s]
+      else
+        @command_fixtures[command_line.name] || :good
+      end
+    else
+      @command_fixtures[command_line.name] || :good
+    end
+  end
+
+  def fixtures_path
+    File.expand_path("../../../fixtures", __FILE__)
+  end
+
+  def load_fixture(dir, key)
+    file = File.join(fixtures_path, dir, "#{key}.yml")
+
+    if File.exist?(file)
+      YAML.load(File.new(file, 'r'))
+    else
+      raise "Missing fixture file `#{file}`"
+    end
+  end
+end

data/test/support/helpers/mock_execution.rb

@@ -0,0 +1,58 @@
+module MockExecution
+  module_function
+
+  def test_env
+    ENV['CF_BINARY'] = 'cf'
+  end
+
+  def test_config(config = {})
+    CfScript.config.io.stdout     = config[:stderr] || StringIO.new
+    CfScript.config.io.stderr     = config[:stderr] || StringIO.new
+
+    CfScript.config.ui.color      = config[:color]  || false
+
+    CfScript.config.runtime.trace = config[:trace]  || true
+  end
+
+  def test_executor(executor)
+    CfScript.config.runtime.executor = executor
+  end
+
+  def fake_process_status(exitstatus = 0)
+    OpenStruct.new(
+      exitstatus: exitstatus,
+      success?:   exitstatus == 0
+    )
+  end
+
+  def fake_output(out = '', err = '', exitstatus = 0)
+    command = CfScript::Command::General::TargetCommand.instance
+    stdout  = out
+    stderr  = err
+    status  = fake_process_status(exitstatus)
+
+    CfScript::Output.new(command, stdout, stderr, status)
+  end
+
+  def fake_command_args(command)
+    arity = command.method(:run).arity
+
+    if arity == -1
+      []
+    else
+      ([:arg] * (arity.abs - 1)) + [{}]
+    end
+  end
+
+  def fake_cf(command_fixtures = {}, &block)
+    config = ConfigContext.new
+
+    test_env
+    test_config
+    test_executor FixtureExecutor.new(command_fixtures)
+
+    yield(CfScript.stdout.string, CfScript.stderr.string)
+  ensure
+    config.reset
+  end
+end

data/test/support/helpers/object_helpers.rb

@@ -0,0 +1,29 @@
+module ObjectHelpers
+  def build_attribute_list(attrs = {})
+    list = CfScript::AttributeList.new()
+
+    attrs.each do |name, value|
+      list << CfScript::Attribute.new(name, value)
+    end
+
+    list
+  end
+
+  def build_instance_status_attrs(options = {})
+  	attrs = build_attribute_list({
+      index:    '0',
+      state:    '1',
+      since:    '2',
+      cpu:    	'3',
+      memory:   '4',
+      disk:   	'5',
+      details:  '6'
+    }.merge(options))
+  end
+
+  def build_instance_status(options = {})
+    attrs = build_instance_status_attrs(options)
+
+		CfScript::InstanceStatus.new(attrs)
+  end
+end

data/test/support/helpers/output_sink.rb

@@ -0,0 +1,25 @@
+module OutputSink
+  module_function
+
+  def start
+    CfScript.config.color  = false
+    CfScript.config.stdout = StringIO.new
+    CfScript.config.stderr = StringIO.new
+  end
+
+  def stdout
+    CfScript.stdout.string
+  end
+
+  def stdout_lines
+    stdout.lines.map(&:strip)
+  end
+
+  def stderr
+    CfScript.stderr.string
+  end
+
+  def stderr_lines
+    stderr.lines.map(&:strip)
+  end
+end

data/test/support/helpers.rb

@@ -0,0 +1,3 @@
+# Load all helper files
+helpers_dir = File.expand_path('../helpers', __FILE__)
+Dir["#{helpers_dir}/*.rb"].each {|f| require f}

data/test/support/shared_examples/command_object.rb

@@ -0,0 +1,38 @@
+shared_examples_for 'a command object that' do |attrs|
+  it "behaves like a subclass of Command::Base" do
+    assert_kind_of CfScript::Command::Base, command
+
+    assert command.respond_to?(:type)
+    assert command.respond_to?(:name)
+    assert command.respond_to?(:run)
+
+    assert_equal attrs[:has_type], command.type
+    assert_equal attrs[:has_name], command.name
+  end
+
+  it "returns fail value when run_cf fails (cf's exit status != 0)" do
+    fake_cf attrs[:has_name] => :fail do
+      args = fake_command_args(command)
+
+      assert_equal attrs[:fails_with], command.run(*args)
+    end
+  end
+
+  it "prints an error message and returns fail value when an API endpoint is not set" do
+    fake_cf attrs[:has_name] => :no_endpoint do |stdout, stderr|
+      args = fake_command_args(command)
+
+      assert_equal attrs[:fails_with], command.run(*args)
+      assert_includes stderr.lines, "{#{attrs[:has_name]}} No API endpoint set\n"
+    end
+  end
+
+  it "prints an error message and returns fail value when not logged in" do
+    fake_cf attrs[:has_name] => :no_login do |stdout, stderr|
+      args = fake_command_args(command)
+
+      assert_equal attrs[:fails_with], command.run(*args)
+      assert_includes stderr.lines, "{#{attrs[:has_name]}} Not logged in\n"
+    end
+  end
+end

data/test/support/shared_examples.rb

@@ -0,0 +1,30 @@
+MiniTest::Test.class_eval do
+  def self.shared_examples
+    @shared_examples ||= {}
+  end
+end
+
+module MiniTest::Test::SharedExamples
+  def shared_examples_for(desc, &block)
+    MiniTest::Test.shared_examples[desc] = block
+  end
+
+  def it_behaves_like(desc, *args)
+    raise "Unknown shared example '#{desc}' in it_behaves_like" unless
+      MiniTest::Test.shared_examples[desc]
+
+    if args.empty?
+      self.instance_eval(&MiniTest::Test.shared_examples[desc])
+    else
+      self.instance_exec(*args, &MiniTest::Test.shared_examples[desc])
+    end
+  end
+
+  alias :it_is :it_behaves_like
+end
+
+Object.class_eval { include(MiniTest::Test::SharedExamples) }
+
+# Load all shared example files
+shared_examples_dir = File.expand_path('../shared_examples', __FILE__)
+Dir["#{shared_examples_dir}/**/*.rb"].each {|f| require f}

data/test/test_helper.rb

@@ -0,0 +1,34 @@
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/test/"
+  end
+end
+
+gem 'minitest'
+
+require 'minitest/autorun'
+require "minitest/focus"
+require 'minitest/pride'
+
+if ENV['REPORTER']
+  require 'minitest/reporters'
+
+  case ENV['REPORTER']
+  when 'spec'
+    Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+  when 'progress'
+    Minitest::Reporters.use! Minitest::Reporters::ProgressReporter.new
+  when 'time'
+    Minitest::Reporters.use! Minitest::Reporters::MeanTimeReporter.new
+  else
+    Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new
+  end
+end
+
+require 'pry'
+require_relative './support/assertions'
+require_relative './support/helpers'
+require_relative './support/shared_examples'
+
+require File.expand_path("../../lib/cf_script", __FILE__)