restfulie 1.0.0 → 1.0.3

data/spec/unit/client/feature/retry_when_unavailable_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Feature::RetryWhenUnavailable do
+  
+  before do
+    @feature = Restfulie::Client::Feature::RetryWhenUnavailable.new
+    @response = mock Net::HTTPResponse
+    @request = Object.new
+    @chain = mock Restfulie::Client::StackNavigator
+    @chain.should_receive(:continue).and_return(@response)
+  end
+  
+  context "when executing a request" do
+    
+    it "should retry execution by default if response code is 503" do
+      second_response = mock Net::HTTPResponse
+      @chain.should_receive(:continue).with(@request, {}).and_return(second_response)
+      @response.stub(:code).and_return(503)
+      @feature.execute(@chain, @request, {}).should == second_response
+    end
+    
+    it "should not retry execution by default if response code is not 503" do
+      @response.stub(:code).and_return(404)
+      @feature.execute(@chain, @request, {}).should == @response
+    end
+    
+    it "should retry execution with a custom behavior" do
+      def @feature.should_retry?(response, env)
+        env["force_retry"] == true
+      end
+      second_response = mock Net::HTTPResponse
+      @chain.should_receive(:continue).and_return(second_response)
+      @feature.execute(@chain, @request, {"force_retry" => true}).should == second_response
+    end
+    
+  end
+
+end

data/spec/unit/client/feature/verb_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Feature::Verb do
+  
+  before do
+    @request = Object.new
+    @request.extend Restfulie::Client::Feature::Verb
+  end
+  
+  context "when invoking throw error based methods" do
+    
+    it "should invoke throw error and delegate invocations on get" do
+      @request.should_receive(:request).with(:throw_error_request)
+      @request.should_receive(:get).with({:key => :value})
+      @request.get!({:key => :value})
+    end
+    
+    ["head", "delete"].each do |method|
+      it "should invoke throw error and delegate invocations on #{method}" do
+        @request.should_receive(:request).with(:throw_error_request)
+        @request.should_receive(method)
+        @request.send "#{method}!"
+      end
+    end
+
+    ["put", "post", "patch"].each do |method|
+      it "should invoke throw error and delegate invocations on #{method}" do
+        body = "{ 'data' : 'content' }"
+        @request.should_receive(:request).with(:throw_error_request)
+        @request.should_receive(method).with(body)
+        @request.send "#{method}!", body
+      end
+    end
+
+  end
+
+end

data/spec/unit/client/http/link_header_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Restfulie::Client::HTTP::LinkHeader do
+  
+  context "when parsing one link header" do
+    
+    it "returns all the parts if present" do
+      headers = {"link"=>["<http://amundsen.com/examples/mazes/2d/ten-by-ten/0:north>; rel=\"start\"; type=\"application/xml\""]}
+      headers.extend Restfulie::Client::HTTP::LinkHeader
+      start = headers.link("start")
+      start.rel.should == "start"
+      start.href.should == "http://amundsen.com/examples/mazes/2d/ten-by-ten/0:north"
+      start.content_type.should == "application/xml"
+    end
+    
+    it "returns empty if one part is not present" do
+      headers = {"link"=>["<http://amundsen.com/examples/mazes/2d/ten-by-ten/0:north>; rel=\"start\";"]}
+      headers.extend Restfulie::Client::HTTP::LinkHeader
+      start = headers.link("start")
+      start.content_type.should be_nil
+    end
+    
+    it "returns nil if the link is not present" do
+      headers = {"link"=>["<http://amundsen.com/examples/mazes/2d/ten-by-ten/0:north>; rel=\"start\""]}
+      headers.extend Restfulie::Client::HTTP::LinkHeader
+      headers.link("south").should be_nil
+    end
+    
+  end
+
+  context "when parsing multiple link headers" do
+    
+    it "should bring back all of them" do
+      headers = {"link"=>['<http://amundsen.com/examples/mazes/2d/ten-by-ten/0:north>; rel="current",<http://amundsen.com/examples/mazes/2d/ten-by-ten/10:east>; rel="east"']}
+      headers.extend Restfulie::Client::HTTP::LinkHeader
+      headers.links.size.should == 2
+      headers.link("current").should_not be_nil
+      headers.link("east").should_not be_nil
+    end
+    
+  end
+
+end

data/spec/unit/client/mikyung/concatenator_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Mikyung::Concatenator do
+
+  it "should use the content if there are no extra args" do
+    Restfulie::Client::Mikyung::Concatenator.new("alive").content.should == "alive"
+  end
+  
+  it "should concatenate at the end if there is some extra content" do
+    Restfulie::Client::Mikyung::Concatenator.new("alive", Restfulie::Client::Mikyung::Concatenator.new("should")).content.should == "alive should"
+  end
+  
+end
+

data/spec/unit/client/mikyung/rest_process_model_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Mikyung::WhenCondition do
+  
+  class MyProcess < Restfulie::Client::Mikyung::RestProcessModel
+    def scenario
+      When "there are products" do |resource|
+        true
+      end
+
+      When "alive" do |resource|
+        true
+      end
+    
+      When "dead" do |resource|
+        false
+      end
+      
+      Then "rest" do |resource|
+      end
+    end
+    
+  end
+  
+  before do
+    @process = MyProcess.new
+    @process.scenario
+  end
+  
+  context "configuring" do
+  
+    it "should concatenate when method missing" do
+      def @process.scenario
+        nobody
+      end
+      @process.scenario.content.should == "nobody"
+    end
+  
+    it "should start a concatenate when method missing" do
+      def @process.scenario
+        nobody but you
+      end
+      @process.scenario.content.should == "nobody but you"
+    end
+  
+    it "should create a when rule when passing a string" do
+      l = lambda { |resource| @executed = true}
+      def @process.scenario(l)
+        When "something happens" do |resource|
+          l.call(resource)
+        end
+      end
+      @process.scenario(l)
+      @process.when_rules.size.should == 4
+      @process.when_rules[3][0].should == "something happens"
+      @process.when_rules[3][1].call("resource")
+      @executed.should be_true
+    end
+  
+    it "should create a new rule when using concatenators" do
+      def @process.scenario
+        When alive
+      end
+      @process.scenario
+      @process.conditions.size.should == 1
+    end
+  
+    it "should complain about a rule that does not yet exist" do
+      def @process.scenario
+        When studying
+      end
+      lambda {@process.scenario}.should raise_error(Restfulie::Client::Mikyung::ConfigurationError)
+    end
+
+    it "should add further restrictions" do
+      def @process.scenario
+        When alive
+        And dead
+      end
+      @process.scenario
+      @process.conditions.size.should == 1
+    end
+
+    it "should add results" do
+      def @process.scenario
+        When alive
+        Then rest
+      end
+      @process.scenario
+      @process.then_rules.size.should == 1
+    end
+  
+    it "should create extra results" do
+      def @process.scenario
+        Then "play" do |resource|
+        end
+      
+        When alive
+        Then play
+      end
+      @process.scenario
+      @process.then_rules.size.should == 2
+    end
+
+  end
+  
+  context "running" do
+    
+    it "should do nothing if there are no conditions" do
+      @process.next_step(nil,nil).should be_nil
+    end
+    
+    it "should do nothing if there is no condition which should be run" do
+      def @process.scenario
+        Then "complain" do
+          "complained"
+        end
+        When dead
+        Then complain
+      end
+      @process.scenario
+      @process.next_step(nil,nil).should be_nil
+    end
+    
+    it "should do something if it matches" do
+      def @process.scenario
+        Then "buy" do
+          "next step executed"
+        end
+        When there are products
+        Then buy
+      end
+      @process.scenario
+      @process.next_step(nil,nil).should == "next step executed"
+    end
+    
+  end
+  
+end
+

data/spec/unit/client/mikyung/steady_state_walker_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Mikyung::SteadyStateWalker do
+  
+  before do
+    @goal = Object.new
+    @current = Object.new
+    @mikyung = Object.new
+    @walker = Restfulie::Client::Mikyung::SteadyStateWalker.new
+  end
+
+  it "should throw an error if there is no step to follow" do
+    @goal.should_receive(:next_step).with(@current, @mikyung)
+    lambda {@walker.move(@goal, @current, @mikyung)}.should raise_error Restfulie::Client::UnableToAchieveGoalError
+  end
+  
+  it "should try to execute the step three times if it is an instantiated object" do
+    next_step = Object.new
+    @goal.should_receive(:next_step).with(@current, @mikyung).and_return(next_step)
+    @walker.should_receive(:try_to_execute).with(next_step, @current, 3, @mikyung).and_return(next_step)
+    @walker.move(@goal, @current, @mikyung).should == next_step
+  end
+  
+  class CustomStep
+  end
+  
+  it "should instantiate the step prior to executing it" do
+    step = CustomStep
+    @goal.should_receive(:next_step).with(@current, @mikyung).and_return(step)
+
+    next_step = CustomStep.new
+    CustomStep.should_receive(:new).and_return(next_step)
+
+    @walker.should_receive(:try_to_execute).with(next_step, @current, 3, @mikyung).and_return(next_step)
+    @walker.move(@goal, @current, @mikyung).should == next_step
+  end
+  
+end
+

data/spec/unit/client/mikyung/then_condition_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+class BasicGoal
+  attr_accessor :then_rules
+end
+
+describe Restfulie::Client::Mikyung::ThenCondition do
+  
+  before do
+    @condition = Restfulie::Client::Mikyung::ThenCondition.new("launch a rocket")
+    @resource = Object.new
+    @goal = BasicGoal.new
+    @mikyung = Object.new
+    @goal.then_rules = []
+    @goal.then_rules << ["send an email", ""]
+  end
+  
+  it "should do nothing if there is no matching rule" do
+    @condition.execute(@resource, @goal, @mikyung).should == nil
+  end
+  
+  it "should invoke with resource if it receives one parameter" do
+    @goal.then_rules << ["launch a rocket", lambda { |resource| true }]
+    @condition.execute(@resource, @goal, @mikyung).should be_true
+  end
+  
+  it "should invoke with two params if it receives two parameters" do
+    @goal.then_rules << ["launch a rocket", lambda { |resource, params| true }]
+    @condition.execute(@resource, @goal, @mikyung).should be_true
+  end
+  
+  it "should invoke with all params if it receives three parameters" do
+    @goal.then_rules << ["launch a rocket", lambda { |resource, params, mikyung| true }]
+    @condition.execute(@resource, @goal, @mikyung).should be_true
+  end
+  
+end
+

data/spec/unit/client/mikyung/when_condition_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Mikyung::WhenCondition do
+  
+  before do
+    @rule = [""]
+    @params = Object.new
+    @condition = Restfulie::Client::Mikyung::WhenCondition.new(nil, @rule, @params)
+    @resource = Object.new
+    @goal = Object.new
+    @mikyung = Object.new
+  end
+
+  it "should execute for every result concatenated" do
+    obj = Object.new
+    def obj.description
+      "will execute something special"
+    end
+    @condition.results_on obj
+    
+    result = Object.new
+    obj.should_receive(:execute).with(@resource, @goal, @mikyung).and_return(result)
+    
+    @condition.execute(@resource, @goal, @mikyung).should == result
+  end
+  
+  it "should not run if its rule without params does not match" do
+    @rule << lambda { |without| false }
+    @condition.should_run_for(@resource, @goal).should be_false
+  end
+
+  it "should not run if its rule with params does not match" do
+    @rule << lam(false)
+    @condition.should_run_for(@resource, @goal).should be_false
+  end
+  
+  def lam(what)
+    lambda { |without, regex| what }
+  end
+  
+  it "should run if its rule says so" do
+    @rule << lam(true)
+    @condition.should_run_for(@resource, @goal).should be_true
+  end
+  
+  it "should run if its rule and extras says so" do
+    @rule << lam(true)
+    @condition.and Restfulie::Client::Mikyung::WhenCondition.new(nil, ["", lam(true)], @params)
+    @condition.should_run_for(@resource, @goal).should be_true
+  end
+  
+  it "should not run if its rule says yes but extras no" do
+    @rule << lam(true)
+    @condition.and Restfulie::Client::Mikyung::WhenCondition.new(nil, ["", lam(false)], @params)
+    @condition.should_run_for(@resource, @goal).should be_false
+  end
+  
+end
+

data/spec/unit/client/mikyung_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Mikyung do
+
+  context "when trying to achieve a goal" do
+  
+    before do
+      @goal = Object.new
+      @start = Object.new
+      @walker = Object.new
+      @client = Restfulie::Mikyung.new.achieve(@goal).at(@start).walks_with(@walker)
+    end
+  
+    it "should allow access to its goal" do
+      @client.goal.should == @goal
+    end
+
+    it "should allow access to its start point" do
+      @client.start.should == @start
+    end
+    
+    it "should allow access to its steady state walker" do
+      @client.walker.should == @walker
+    end
+
+    it "should not walk if goal starts completed" do
+      @goal.should_receive(:completed?).with(@start).and_return(true)
+      @restfulie = mock Restfulie::Client::Mikyung
+      @restfulie.should_receive(:get).and_return(@start)
+      @goal.class.should_receive(:get_restfulie).and_return(@restfulie)
+      @goal.should_receive(:steps).and_return(nil)
+      @goal.should_receive(:scenario).and_return(nil)
+      @client.run
+    end
+    
+    it "should walk until its completed" do
+      @goal.should_receive(:completed?).with(@start).and_return(false)
+      second = Object.new
+      @walker.should_receive(:move).with(@goal, @start, @client).and_return(second)
+      @goal.should_receive(:completed?).with(second).and_return(true)
+      @restfulie = mock Restfulie::Client::Mikyung
+      @restfulie.should_receive(:get).and_return(@start)
+      @goal.class.should_receive(:get_restfulie).and_return(@restfulie)
+      @goal.should_receive(:steps).and_return(nil)
+      @goal.should_receive(:scenario).and_return(nil)
+     @client.run
+    end
+    
+  end
+  
+  context "starting with an URI" do
+    
+    it "should start invoking a restfulie get if the entry point is an uri" do
+      start = "http://www.caelumobjects.com"
+      restfulie = mock Restfulie::Client::Mikyung
+      Restfulie.should_receive(:at).with(start).and_return(restfulie)
+      
+      resource = Object.new
+      restfulie.should_receive(:get).and_return(resource)
+
+      client = Object.new
+      walker = Object.new
+      goal = Object.new
+      goal.should_receive(:completed?).with(resource).and_return(true)
+      goal.should_receive(:steps).and_return(nil)
+      goal.should_receive(:scenario).and_return(nil)
+     Restfulie::Mikyung.new.achieve(goal).at(start).run
+    end
+    
+  end
+
+end