flux 0.0.3 → 0.0.5

data/spec/flux/rcs/git_spec.rb

@@ -1,47 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-require 'flux/rcs/git'
-
-describe Flux::RCS::Branches do
-  include Flux::Util::Output
-
-  it "displays the current branch" do
-    mock(mock_root(Grit::Repo)).head.mock!.name { 'zee_current_branch' }
-
-    retval = nil
-    capture { retval = subject.invoke('branches:current', []) }.
-      should == "zee_current_branch\n"
-    retval.should == 'zee_current_branch'
-  end
-
-  it "creates a branch" do
-    mock(mock_root(Grit::Git)).branch({}, 'new_branch')
-
-    subject.invoke 'branches:create', %w(new_branch)
-  end
-
-  it "creates a public branch" do
-    git = mock_root(Grit::Git)
-
-    mock(git).branch({}, 'new_branch')
-    mock(git).push({}, 'origin', '+new_branch:new_branch')
-    mock(git).branch({:set_upstream => true}, 'new_branch', 'origin/new_branch')
-
-    subject.invoke 'branches:create', %w(new_branch), :public => true
-  end
-
-  it "checks out a branch" do
-    mock(mock_root(Grit::Git)).checkout({}, 'new_branch')
-
-    subject.invoke 'branches:checkout', %w(new_branch)
-  end
-
-  def mock_root(klass)
-    repo_path = File.expand_path(File.dirname(__FILE__) + '/../../../.git')
-    root      = Object.new
-
-    mock(klass).new(repo_path) { root }
-
-    root
-  end
-end

data/spec/flux/trackers/pivotal_tracker_spec.rb

@@ -1,164 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-require 'flux/trackers/pivotal_tracker'
-
-describe Flux::Trackers::PivotalTracker do
-  let(:environment) {
-    {'trackers' => {'project_id' => PROJECT.id,
-                    'token'      => PROJECT.token,
-                    'email'      => 'david@mojotech.com'}}
-  }
-
-  before { Flux.environment = environment }
-
-  it "lists stories by iteration" do
-    mock(PivotalTracker::Iteration).current_backlog(fake_project) {
-      [OpenStruct.new(:stories => [
-                        OpenStruct.new(:id            => 1,
-                                       :current_state => 'unstarted',
-                                       :owned_by      => '',
-                                       :name          => 'first story')]),
-       OpenStruct.new(:stories => [
-                        OpenStruct.new(:id            => 2,
-                                       :current_state => 'started',
-                                       :owned_by      => 'David Leal',
-                                       :name          => 'second story')])]
-    }
-
-    t = [['ID', 'STATE', 'ASSIGNEE', 'STORY'],
-         [1, 'unstarted', '', 'first story'],
-         [2, 'started', 'David Leal', 'second story']]
-
-    lambda { subject.invoke :list }.should print_table(t)
-  end
-
-  it "grabs a story" do
-    prepare_myself
-
-    mock_update(123, 'owned_by' => 'David Leal')
-
-    subject.invoke :grab, [123]
-  end
-
-  it "grabs a story and estimates it" do
-    prepare_myself
-
-    mock_update(123, 'owned_by' => 'David Leal',
-                     'estimate' => 2)
-
-    subject.invoke :grab, [123], :estimate => 2
-  end
-
-  [%w(starts started start),
-   %w(finishes finished finish)].each do |(action, state, task)|
-    it "#{action} a story that was already estimated" do
-      s = mock_update(123, 'current_state' => state)
-      s.estimate = 2
-
-      subject.invoke task, [123]
-    end
-
-    it "#{action} a story that needs to be estimated" do
-      mock_update(123, 'current_state' => state, 'estimate' => 2)
-
-      subject.invoke task, [123], :estimate => 2
-    end
-  end
-
-  describe "attributes" do
-    it "updates custom attributes" do
-      attrs = {'branch' => 'blah', 'other' => 'yay'}
-
-      mock_find(123)
-      mock(PivotalTracker::Note).new(observe { |h|
-                                       h[:owner].id == 123 &&
-                                       h[:text] == YAML.dump(attrs)
-                                     }).mock!.create
-
-      subject.invoke :update, [123], :attributes => attrs
-    end
-
-    it "updates native attributes" do
-      attrs = {'owner'    => 'David Leal',
-               'state'    => 'started',
-               'estimate' => 2,
-               'name'     => 'My story'}
-
-      mock_update(123,
-                  'owned_by'      => 'David Leal',
-                  'current_state' => 'started',
-                  'estimate'      => 2,
-                  'name'          => 'My story')
-
-      subject.invoke :update, [123], :attributes => attrs
-    end
-
-    it "updates valid states only" do
-      attrs = {'state' => 'sitting'}
-
-      s = mock_find(123)
-
-      lambda { subject.invoke :update, [123], :attributes => attrs }.
-        should raise_error(Flux::TrackerError, /Invalid state/)
-    end
-
-    it "updates state when story has estimate" do
-      attrs = {'state' => 'started'}
-
-      s          = mock_update(123, 'current_state' => 'started')
-      s.estimate = 2
-
-      subject.invoke :update, [123], :attributes => attrs
-    end
-
-    it "updates state when story estimate is given" do
-      attrs = {'state' => 'started', 'estimate' => 2}
-
-      s = mock_update(123, 'current_state' => 'started',
-                           'estimate'      => 2)
-
-      subject.invoke :update, [123], :attributes => attrs
-    end
-
-    Flux::Trackers::PivotalTracker::STATES_W_ESTIMATE.each do |state|
-      it "fails to update state `#{state}' if no estimate given" do
-        attrs = {'state' => state}
-
-        s = mock_find(123)
-
-        lambda { subject.invoke :update, [123], :attributes => attrs }.
-          should raise_error(Flux::TrackerError, /Need an estimate/)
-      end
-    end
-  end
-
-  def iteration(which, data)
-    mock(PivotalTracker::Iteration).__send__(which, fake_project) {
-      OpenStruct.new(:stories => data.map { |d| OpenStruct.new(d) })
-    }
-  end
-
-  def fake_project
-    OpenStruct.new(:id => PROJECT.id)
-  end
-
-  def fake_story(id)
-    PivotalTracker::Story.new(:id => id, :project_id => PROJECT.id)
-  end
-
-  def mock_find(story_id)
-    fake_story(story_id).tap { |s|
-      mock(PivotalTracker::Story).find(story_id, PROJECT.id) { s }
-    }
-  end
-
-  def mock_update(story_id, attrs)
-    mock_find(story_id).tap { |s| mock(s).update(attrs) }
-  end
-
-  def prepare_myself
-    mock(PivotalTracker::Membership).all(fake_project) {
-      [OpenStruct.new(:name => 'David Leal', :email => 'david@mojotech.com')]
-    }
-  end
-end

data/spec/flux/util/table_spec.rb

@@ -1,47 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Flux::Util::Table do
-  let(:body) {
-    [[123, 'unstarted', 'David Leal', 'First story'],
-     [456, 'unscheduled', '', 'Second story']]
-  }
-
-  it "is converted to a string" do
-    t = Flux::Util::Table.new(Thor::Shell::Basic.new,
-                              [%w(ID STATE ASSIGNEE STORY)] + body,
-                              '  ',
-                              nil)
-
-    t.to_s.should == <<EOT
-ID   STATE        ASSIGNEE    STORY
-123  unstarted    David Leal  First story
-456  unscheduled              Second story
-EOT
-  end
-
-  it "aligns its columns to the right" do
-    t = Flux::Util::Table.new(Thor::Shell::Basic.new,
-                              [%w(>ID >STATE >ASSIGNEE >STORY)] + body,
-                              '  ',
-                              nil)
-
-    t.to_s.should == <<EOT
- ID        STATE    ASSIGNEE         STORY
-123    unstarted  David Leal   First story
-456  unscheduled              Second story
-EOT
-  end
-
-  it "truncates lines to a given width" do
-    t = Flux::Util::Table.new(Thor::Shell::Basic.new,
-                              [%w(ID STATE ASSIGNEE STORY)] + body,
-                              '  ',
-                              7)
-
-    t.to_s.should == <<EOT
-ID  ...
-123 ...
-456 ...
-EOT
-  end
-end

data/spec/support/matchers/print_table.rb

@@ -1,46 +0,0 @@
-RSpec::Matchers.define :print_table do |data|
-  class FakeStdout
-    attr_reader :table
-
-    def initialize(stdout)
-      @stdout = stdout
-    end
-
-    def puts(*args)
-      case args.first
-      when Flux::Util::Table
-        @table = args.first
-      else
-        @stdout.puts *args
-      end
-    end
-
-    def write(data)
-      @stdout.write data
-    end
-  end
-
-
-  match do |block|
-    stdout  = $stdout
-    $stdout = @stdout = FakeStdout.new(stdout)
-
-    begin
-      block.call
-
-      @stdout.table.should_not be_nil
-      @stdout.table.data.should == data
-    ensure
-      $stdout = stdout
-    end
-  end
-
-  failure_message_for_should do |block|
-    "Expected table:\n\n#{Flux::Util::Table.new(data, '  ', nil)}\n" <<
-      "but got:\n\n#{@stdout.table ? @stdout.table : 'nil'}"
-  end
-
-  failure_message_for_should_not do |block|
-    raise NotImplementedError
-  end
-end