restfulie-nosqlite 1.0.3

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

data/spec/unit/client/stack_navigator.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Restfulie::Client::StackNavigator do
+  
+  context "when navigating through the filter list" do
+    
+    class DoNothing
+      def execute(stack, *args)
+      end
+    end
+    
+    class InvokeNext
+      def execute(stack, *args)
+        stack.continue(*args)
+      end
+    end
+    
+    it "should invoke the first one" do
+      do_nothing = DoNothing.new
+      DoNothing.should_receive(:new).and_return(do_nothing)
+      parser = Restfulie::Client::StackNavigator.new([:type => DoNothing])
+      def parser.dup
+        self
+      end
+      
+      args = [:req, :env]
+
+      do_nothing.should_receive(:execute).with(parser, *args)
+      parser.continue(*args)
+    end
+
+    it "should invoke first the most recent ones" do
+      do_nothing = DoNothing.new
+      DoNothing.should_receive(:new).and_return(do_nothing)
+      parser = Restfulie::Client::StackNavigator.new([:type => InvokeNext, :type => DoNothing])
+      def parser.dup
+        self
+      end
+      
+      args = [:req, :env]
+
+      do_nothing.should_receive(:execute).with(parser, *args)
+      parser.continue(*args)
+    end
+    
+  end
+  
+  class Client
+    def initialize(name)
+      @name = name
+    end
+    attr_reader :name
+  end
+
+  class Owner
+    def initialize(name = "adriano")
+      @name = name
+    end
+    attr_reader :name
+  end
+
+  context "when instantiating filters" do
+    it "should pass on the arg" do
+      instantiator = Restfulie::Client::BasicInstantiator.new
+      client = instantiator.new Client, "guilherme"
+      client.name.should == "guilherme"
+    end
+    it "should be capable of instantiating with no args" do
+      instantiator = Restfulie::Client::BasicInstantiator.new
+      client = instantiator.new Owner, nil
+      client.name.should == "adriano"
+    end
+  end
+
+end

data/spec/unit/common/errors_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Restfulie::Common::Error do
+  describe Restfulie::Common::Error::RestfulieError do
+    it "RestfulieError should have StandardError as ancestors class" do
+      msg = "Restfulie Error test"
+      Restfulie::Common::Error::RestfulieError.ancestors.should be_include StandardError
+      lambda {
+        raise Restfulie::Common::Error::RestfulieError.new(msg)
+      }.should raise_error(Restfulie::Common::Error::RestfulieError, msg)
+    end
+  end
+
+  describe Restfulie::Common::Error::MarshallingError do
+    it "MarshallingError should have RestfulieError as ancestors class" do
+      msg = "Restfulie Marshalling Error test"
+      Restfulie::Common::Error::MarshallingError.ancestors.should be_include Restfulie::Common::Error::RestfulieError
+      lambda {
+        raise Restfulie::Common::Error::MarshallingError.new(msg)
+      }.should raise_error(Restfulie::Common::Error::MarshallingError, msg)
+    end
+  end
+
+  describe Restfulie::Common::Error::UndefinedMarshallingError do
+    it "UndefinedMarshallingError should have MarshallingError as ancestors class" do
+      msg = "Restfulie Marshalling Error test"
+      Restfulie::Common::Error::UndefinedMarshallingError.ancestors.should be_include Restfulie::Common::Error::MarshallingError
+      lambda {
+        raise Restfulie::Common::Error::UndefinedMarshallingError.new(msg)
+      }.should raise_error(Restfulie::Common::Error::UndefinedMarshallingError, msg)
+    end
+  end
+end

data/spec/unit/restfulie_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Restfulie do
+
+  context "when building restfulie" do
+  
+    it "should create a restfulie with an at method" do
+      Restfulie.respond_to?(:at).should be_true
+    end
+    
+    module Restfulie::Client::Feature::Custom
+      def custom_history
+      end
+    end
+    class Restfulie::Client::Feature::CustomRequest
+      def custom_history
+      end
+    end
+    
+    it "should allow adding extra methods by usage" do
+      Restfulie.use{custom}.respond_to?(:custom_history).should be_true
+    end
+    
+    it "should accepts the old methods after adding new ones" do
+      Restfulie.use{custom}.respond_to?(:at).should be_true
+    end
+    
+  end
+
+end

data/spec/unit/server/action_controller/trait/cacheable_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Restfulie::Server::ActionController::Trait::Cacheable do
+
+  context "using a Trait::Cacheable responder" do
+
+
+    module ToFormatReceiver
+      attr_accessor :received
+      def to_format
+        @received = true
+      end
+    end
+
+    let(:responder) do
+      responder = Object.new
+      responder.extend ToFormatReceiver
+      responder.extend ::Restfulie::Server::ActionController::Trait::Cacheable
+    end
+
+    it "should superize if not cached" do
+      responder.stub(:is_cached?).and_return(false)
+      responder.stub(:cache_request).and_return("")
+
+      responder.to_format
+      responder.received.should be_true
+    end
+
+
+    it "should cache requests" do
+      responder.stub(:is_cached?).and_return(false)
+      
+      @fake_headers = "cache me!"
+      responder.stub(:cache_control_headers).and_return(@fake_headers)
+      
+      expires_mock = double('Expires')
+      expires_mock.should_receive(:do_http_cache).with(responder, @fake_headers)
+
+      last_modifieds = double('Last Modifies')
+      last_modifieds.should_receive(:do_http_cache).with(responder, @fake_headers)
+      
+      responder.stub(:caches).and_return([expires_mock, last_modifieds])
+
+      responder.to_format
+    end
+
+  end
+end

data/spec/unit/server/action_controller/trait/created_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Restfulie::Server::ActionController::Trait::Created do
+  
+  context "using a Trait::Created responder" do
+    
+    module ToFormatReceiver
+      attr_accessor :received
+      def to_format
+        @received = true
+      end
+    end
+
+    it "should superize if its not a created result" do
+      responder = Object.new
+      responder.extend ToFormatReceiver
+      responder.extend Restfulie::Server::ActionController::Trait::Created
+      responder.stub(:options).and_return({:status => 300})
+      responder.to_format
+      responder.received.should be_true
+    end
+
+    it "should head if the response is created" do
+      should_head_with(:created)
+    end
+    
+    it "should head if the response is created" do
+      should_head_with(201)
+    end
+    
+    class MySong
+    end
+    
+    def should_head_with(what)
+      uri = "custom_uri"
+      resource = MySong.new
+      controller = Object.new
+      controller.should_receive(:url_for).with(resource).and_return(uri)
+      
+      responder = Object.new
+      responder.extend Restfulie::Server::ActionController::Trait::Created
+      responder.stub(:resource).and_return(resource)
+      responder.stub(:options).and_return({:status => what})
+      responder.should_receive(:controller).and_return(controller)
+      responder.should_receive(:render).with(:status => 201, :location => uri, :text => "")
+      responder.to_format
+    end
+  end
+
+end

data/spec/unit/server/configuration_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Restfulie::Server::Configuration do
+  
+  it "setup should yield self" do
+    Restfulie::Server::Configuration.setup do |config|
+      config.should equal Restfulie::Server::Configuration
+    end
+  end
+  
+  
+  context "save configurations in Restfulie::Server" do
+
+    before do
+      Restfulie::Server::Configuration.setup do |config|
+        config.host = "myhost.com"
+        config.named_route_prefix = :prefix
+      end      
+    end
+    
+    it "should have a default host configuration" do
+      Restfulie::Server::Configuration.host.should eql "myhost.com"
+    end
+    
+    it  "should have a default named route prefix" do
+      Restfulie::Server::Configuration.named_route_prefix.should equal :prefix
+    end
+    
+  end
+  
+  after(:all) do
+    Restfulie::Server::Configuration.host = "localhost:3000"
+    Restfulie::Server::Configuration.named_route_prefix = nil
+  end
+end
+

data/spec/unit/server/core_ext/array_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Array do
+  
+  class SimpleElement
+    attr_accessor :updated_at, :published_at
+    def initialize
+      @updated_at = @published_at = Time.now
+    end
+  end
+
+  it "should use the most recent date as updated one" do
+    first = SimpleElement.new
+    second = SimpleElement.new
+    
+    [first, second].updated_at.should == second.updated_at
+    [first, first].updated_at.should == first.updated_at
+    
+    now = Time.now
+    Time.should_receive(:now).and_return(now)
+    [].updated_at.should == now
+  end
+  
+  it "should return the oldest published date" do
+    first = SimpleElement.new
+    second = SimpleElement.new
+
+    [first, second].published_at.should == first.published_at
+    [first, first].published_at.should == first.published_at
+    
+    now = 545
+    Time.should_receive(:now).and_return(now)
+    [].updated_at.should == now
+  end
+end