rubywarrior-i18n 0.0.2

data/spec/ruby_warrior/tower_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe RubyWarrior::Tower do
+  before(:each) do
+    @tower = RubyWarrior::Tower.new('path/to/tower')
+  end
+  
+  it "should consider last part of path as name" do
+    @tower.name.should == 'tower'
+  end
+  
+  it "should use name when converting to string" do
+    @tower.to_s.should == @tower.name
+  end
+end

data/spec/ruby_warrior/turn_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe RubyWarrior::Turn do
+  describe "with actions" do
+    before(:each) do
+      @turn = RubyWarrior::Turn.new({:walk! => nil, :attack! => nil})
+    end
+    
+    it "should have no action performed at first" do
+      @turn.action.should be_nil
+    end
+    
+    it "should be able to perform action and recall it" do
+      @turn.walk!
+      @turn.action.should == [:walk!]
+    end
+    
+    it "should include arguments passed to action" do
+      @turn.walk! :forward
+      @turn.action.should == [:walk!, :forward]
+    end
+    
+    it "should not be able to call multiple actions per turn" do
+      @turn.walk! :forward
+      lambda { @turn.attack! }.should raise_error
+    end
+  end
+  
+  describe "with senses" do
+    before(:each) do
+      @feel = RubyWarrior::Abilities::Feel.new(Object.new)
+      @feel.stubs(:space).returns(Object.new)
+      @feel.stubs(:space).with(:backward).returns(Object.new)
+      @turn = RubyWarrior::Turn.new({:feel => @feel})
+    end
+    
+    it "should be able to call sense with any argument and return expected results" do
+      @turn.feel.should == @feel.perform
+      @turn.feel(:backward).should == @feel.perform(:backward)
+    end
+  end
+end

data/spec/ruby_warrior/ui_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe RubyWarrior::UI do
+  before(:each) do
+    @ui = RubyWarrior::UI
+    @config = RubyWarrior::Config
+    @out = StringIO.new
+    @in = StringIO.new
+    @config.out_stream = @out
+    @config.in_stream = @in
+  end
+  
+  it "should add puts to out stream" do
+    @ui.puts "hello"
+    @out.string.should == "hello\n"
+  end
+  
+  it "should add print to out stream without newline" do
+    @ui.print "hello"
+    @out.string.should == "hello"
+  end
+  
+  it "should fetch gets from in stream" do
+    @in.puts "bar"
+    @in.rewind
+    @ui.gets.should == "bar\n"
+  end
+  
+  it "should gets should return empty string if no input" do
+    @config.in_stream = nil
+    @ui.gets.should == ""
+  end
+  
+  it "should request text input" do
+    @in.puts "bar"
+    @in.rewind
+    @ui.request("foo").should == "bar"
+    @out.string.should == "foo"
+  end
+  
+  it "should ask for yes/no and return true when yes" do
+    @ui.expects(:request).with('foo? [yn] ').returns('y')
+    @ui.ask("foo?").should be_true
+  end
+  
+  it "should ask for yes/no and return false when no" do
+    @ui.stubs(:request).returns('n')
+    @ui.ask("foo?").should be_false
+  end
+  
+  it "should ask for yes/no and return false for any input" do
+    @ui.stubs(:request).returns('aklhasdf')
+    @ui.ask("foo?").should be_false
+  end
+  
+  it "should present multiple options and return selected one" do
+    @ui.expects(:request).with(includes('item')).returns('2')
+    @ui.choose('item', [:foo, :bar, :test]).should == :bar
+    @out.string.should include('[1] foo')
+    @out.string.should include('[2] bar')
+    @out.string.should include('[3] test')
+  end
+  
+  it "choose should accept array as option" do
+    @ui.stubs(:request).returns('3')
+    @ui.choose('item', [:foo, :bar, [:tower, 'easy']]).should == :tower
+    @out.string.should include('[3] easy')
+  end
+  
+  it "choose should return option without prompt if only one item" do
+    @ui.expects(:puts).never
+    @ui.expects(:gets).never
+    @ui.stubs(:request).returns('3')
+    @ui.choose('item', [:foo]).should == :foo
+  end
+  
+  it "choose should return first value in array of option if only on item" do
+    @ui.choose('item', [[:foo, :bar]]).should == :foo
+  end
+  
+  it "should delay after puts when specified" do
+    @config.delay = 1.3
+    @ui.expects(:puts).with("foo")
+    @ui.expects(:sleep).with(1.3)
+    @ui.puts_with_delay("foo")
+  end
+  
+  it "should not delay puts when delay isn't specified" do
+    @ui.expects(:puts).with("foo")
+    @ui.expects(:sleep).never
+    @ui.puts_with_delay("foo")
+  end
+end

data/spec/ruby_warrior/units/archer_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe RubyWarrior::Units::Archer do
+  before(:each) do
+    @archer = RubyWarrior::Units::Archer.new
+  end
+  
+  it "should have look and shoot abilities" do
+    @archer.abilities.keys.to_set.should == [:shoot!, :look].to_set
+  end
+  
+  it "should have shoot power of 3" do
+    @archer.shoot_power.should == 3
+  end
+  
+  it "should have 7 max health" do
+    @archer.max_health.should == 7
+  end
+  
+  it "should appear as a on map" do
+    @archer.character.should == "a"
+  end
+end

data/spec/ruby_warrior/units/base_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe RubyWarrior::Units::Base do
+  before(:each) do
+    @unit = RubyWarrior::Units::Base.new
+  end
+  
+  it "should have an attack power which defaults to zero" do
+    @unit.attack_power.should be_zero
+  end
+  
+  it "should consider itself dead when no position" do
+    @unit.position.should be_nil
+    @unit.should_not be_alive
+  end
+  
+  it "should consider itself alive with position" do
+    @unit.position = stub
+    @unit.should be_alive
+  end
+  
+  it "should default max health to 10" do
+    @unit.max_health.should be_zero
+  end
+  
+  it "should do nothing when earning points" do
+    lambda { @unit.earn_points(10) }.should_not raise_error
+  end
+  
+  it "should default health to max health" do
+    @unit.stubs(:max_health).returns(10)
+    @unit.health.should == 10
+  end
+  
+  it "should subtract health when taking damage" do
+    @unit.stubs(:max_health).returns(10)
+    @unit.take_damage(3)
+    @unit.health.should == 7
+  end
+  
+  it "should do nothing when taking damage if health isn't set" do
+    lambda { @unit.take_damage(3) }.should_not raise_error
+  end
+  
+  it "should set position to nil when running out of health" do
+    @unit.position = stub
+    @unit.stubs(:max_health).returns(10)
+    @unit.take_damage(10)
+    @unit.position.should be_nil
+  end
+  
+  it "should print out line with name when speaking" do
+    RubyWarrior::UI.expects(:puts_with_delay).with("[base.name.capitalize] foo")
+    @unit.say "foo"
+  end
+  
+  it "should return name in to_s" do
+    @unit.name.should match /base/
+    @unit.to_s.should match /base/
+  end
+  
+  it "should prepare turn by calling play_turn with next turn object" do
+    @unit.stubs(:next_turn).returns('next_turn')
+    @unit.expects(:play_turn).with('next_turn')
+    @unit.prepare_turn
+  end
+  
+  it "should perform action when calling perform on turn" do
+    @unit.position = stub
+    RubyWarrior::Abilities::Walk.any_instance.expects(:perform).with(:backward)
+    @unit.add_abilities(:walk!)
+    turn = stub(:action => [:walk!, :backward])
+    @unit.stubs(:next_turn).returns(turn)
+    @unit.prepare_turn
+    @unit.perform_turn
+  end
+  
+  it "should not perform action when dead (no position)" do
+    @unit.position = nil
+    RubyWarrior::Abilities::Walk.any_instance.stubs(:perform).raises("action should not be called")
+    @unit.add_abilities(:walk!)
+    turn = stub(:action => [:walk!, :backward])
+    @unit.stubs(:next_turn).returns(turn)
+    @unit.prepare_turn
+    @unit.perform_turn
+  end
+  
+  it "should not raise an exception when calling perform_turn when there's no action" do
+    @unit.prepare_turn
+    lambda { @unit.perform_turn }.should_not raise_error
+  end
+  
+  it "should pass abilities to new turn when calling next_turn" do
+    RubyWarrior::Turn.expects(:new).with(:walk! => nil, :attack! => nil, :feel => nil).returns('turn')
+    @unit.stubs(:abilities).returns(:walk! => nil, :attack! => nil, :feel => nil)
+    @unit.next_turn.should == 'turn'
+  end
+  
+  it "should add ability" do
+    RubyWarrior::Abilities::Walk.expects(:new).with(@unit).returns('walk')
+    @unit.add_abilities(:walk!)
+    @unit.abilities.should == { :walk! => 'walk' }
+  end
+  
+  it "should appear as question mark on map" do
+    @unit.character.should == "?"
+  end
+  
+  it "should be released from bonds when taking damage" do
+    @unit.stubs(:max_health).returns(10)
+    @unit.bind
+    @unit.should be_bound
+    @unit.take_damage(2)
+    @unit.should_not be_bound
+  end
+  
+  it "should be released from bonds when calling release" do
+    @unit.bind
+    @unit.unbind
+    @unit.should_not be_bound
+  end
+  
+  it "should not perform action when bound" do
+    @unit.position = stub
+    @unit.bind
+    RubyWarrior::Abilities::Walk.any_instance.stubs(:perform).raises("action should not be called")
+    @unit.add_abilities(:walk!)
+    turn = stub(:action => [:walk!, :backward])
+    @unit.stubs(:next_turn).returns(turn)
+    @unit.prepare_turn
+    @unit.perform_turn
+  end
+end

data/spec/ruby_warrior/units/captive_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe RubyWarrior::Units::Captive do
+  before(:each) do
+    @captive = RubyWarrior::Units::Captive.new
+  end
+  
+  it "should have 1 max health" do
+    @captive.max_health.should == 1
+  end
+  
+  it "should appear as C on map" do
+    @captive.character.should == "C"
+  end
+  
+  it "should be bound by default" do
+    @captive.should be_bound
+  end
+  
+  it "should not have explode ability by default (this should be added when needed)" do
+    @captive.abilities.should_not include(:explode!)
+  end
+end

data/spec/ruby_warrior/units/golem_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe RubyWarrior::Units::Golem do
+  before(:each) do
+    @golem = RubyWarrior::Units::Golem.new
+  end
+  
+  it "should execute turn proc when playing turn" do
+    proc = Object.new
+    proc.expects(:call).with(:turn)
+    @golem.turn = proc
+    @golem.play_turn(:turn)
+  end
+  
+  it "should set max health and update current health" do
+    @golem.max_health = 10
+    @golem.max_health.should == 10
+    @golem.health.should == 10
+  end
+  
+  it "should have attack power of 3" do
+    @golem.attack_power.should == 3
+  end
+  
+  it "should appear as G on map" do
+    @golem.character.should == "G"
+  end
+end

data/spec/ruby_warrior/units/sludge_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe RubyWarrior::Units::Sludge do
+  before(:each) do
+    @sludge = RubyWarrior::Units::Sludge.new
+  end
+  
+  it "should have attack action" do
+    @sludge.abilities.keys.should include(:attack!)
+  end
+  
+  it "should have feel sense" do
+    @sludge.abilities.keys.should include(:feel)
+  end
+  
+  it "should have attack power of 3" do
+    @sludge.attack_power.should == 3
+  end
+  
+  it "should have 12 max health" do
+    @sludge.max_health.should == 12
+  end
+  
+  it "should appear as s on map" do
+    @sludge.character.should == "s"
+  end
+end

data/spec/ruby_warrior/units/thick_sludge_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe RubyWarrior::Units::ThickSludge do
+  before(:each) do
+    @sludge = RubyWarrior::Units::ThickSludge.new
+  end
+  
+  it "should have 24 max health" do
+    @sludge.max_health.should == 24
+  end
+  
+  it "should appear as S on map" do
+    @sludge.character.should == "S"
+  end
+  
+  it "should have the name of 'Thick Sludge'" do
+    @sludge.name.should == "Thick sludge"
+  end
+end

data/spec/ruby_warrior/units/warrior_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+class Player
+  def turn(warrior)
+  end
+end
+
+describe RubyWarrior::Units::Warrior do
+  before(:each) do
+    @warrior = RubyWarrior::Units::Warrior.new
+  end
+  
+  it "should default name to warrior" do
+    @warrior.name.should == "Warrior"
+    @warrior.name = ''
+    @warrior.name.should == "Warrior"
+  end
+  
+  it "should be able to set name" do
+    @warrior.name = "Joe"
+    @warrior.name.should == "Joe"
+    @warrior.to_s.should == "Joe"
+  end
+  
+  it "should have 20 max health" do
+    @warrior.max_health.should == 20
+  end
+  
+  it "should have 0 score at beginning and be able to earn points" do
+    @warrior.score.should be_zero
+    @warrior.earn_points(5)
+    @warrior.score.should == 5
+  end
+  
+  it "should call player.play_turn and pass turn to player" do
+    player = stub
+    player.expects(:play_turn).with('turn')
+    @warrior.stubs(:player).returns(player)
+    @warrior.play_turn('turn')
+  end
+  
+  it "should call Player.new the first time loading player, and return same object next time" do
+    Player.expects(:new).returns('player').times(1)
+    2.times do
+      @warrior.player.should == 'player'
+    end
+  end
+  
+  it "should have an attack power of 5" do
+    @warrior.attack_power.should == 5
+  end
+  
+  it "should have an shoot power of 3" do
+    @warrior.shoot_power.should == 3
+  end
+  
+  it "should appear as @ on map" do
+    @warrior.character.should == "@"
+  end
+  
+  it "should be able to add golem abilities which are used on base golem" do
+    @warrior.add_golem_abilities :walk!
+    @warrior.base_golem.abilities.keys.should == [:walk!]
+  end
+end