superdupe 0.4.0 → 0.5.0

data/README.markdown

@@ -7,4 +7,40 @@ SuperDupe provides two things:
 SuperDupe is a fork of the originally gem dupe 0.5.1 (Matt Parker). At first, the gem try to use only the available mocked resources. If you have the requirement to send external requests without mocking, take an extra parameter for this situation.
 
 # Install the gem
-    gem install superdupe
+    gem install superdupe
+    
+# Usage
+*Implemented ActiveResource class*
+    class Customer < ActiveResource::Base
+      self.site = ''
+    end
+
+*Register a mock response*
+    Dupe.create <class_name>, <attributes>
+    Dupe.create Customer, :name => 'test customer'
+    
+*Find a registered object*
+    Customer.find 1
+    
+*Find all registered objects*
+    Customer.find :all
+    
+*Find registered url patterns*
+    Dupe.network.mocks[<http-method>]
+    Dupe.network.mocks[:get]
+    
+*Reset registered url patterns*
+    Dupe.reset
+    
+*Register a custom mock with a param-filter*
+    Get %r{\/customers\.xml\?state=(active|inactive)} do |state|
+      if state == 'active'
+        Dupe.find(:"Customers") {|c| c.state == 'active'}
+      else
+        Dupe.find(:"Customers") {|c| c.state == 'inactive'}
+      end
+    end
+    # Register a custom mock with the entered url pattern
+    
+*Find the custom registered object*
+    Customer.find :all, :params => {:state => 'active'}

data/lib/superdupe/active_resource_extensions.rb

@@ -15,8 +15,9 @@ module ActiveResource #:nodoc:
       # Overwrite the configuration of ActiveResource authentication (self.password). Don't need it for mocking.
       def password=(password)
       end
+
       
-      def find(*arguments)      
+      def find(*arguments)
         scope = arguments.slice!(0)
         options = arguments.slice!(0) || {}
 

data/lib/superdupe/dupe.rb

@@ -168,33 +168,35 @@ class Dupe
       model_object.tap do |m|
         models[model_name] = m
         database.create_table model_name
+                
         mocks = %{
           network.define_service_mock(
             :get, 
-            %r{^#{model_name.to_s.titleize.constantize.prefix rescue '/'}#{model_name.to_s.pluralize}\\.xml$}, 
-            proc { Dupe.find(:#{model_name.to_s.pluralize}) }
+            %r{^#{model_name.to_s.constantize.prefix rescue '/'}#{model_name.to_s.demodulize.downcase.pluralize}\\.xml$}, 
+            proc { Dupe.find(:"#{model_name.to_s.pluralize}") }
           )
           network.define_service_mock(
             :get, 
-            %r{^#{model_name.to_s.titleize.constantize.prefix rescue '/'}#{model_name.to_s.pluralize}/(\\d+)\\.xml$}, 
-            proc {|id| Dupe.find(:#{model_name}) {|resource| resource.id == id.to_i}}
+            %r{^#{model_name.to_s.constantize.prefix rescue '/'}#{model_name.to_s.demodulize.downcase.pluralize}/(\\d+)\\.xml$}, 
+            proc {|id| Dupe.find(:"#{model_name.to_s}") {|resource| resource.id == id.to_i}}
           )
           network.define_service_mock(
             :post, 
-            %r{^#{model_name.to_s.titleize.constantize.prefix rescue '/'}#{model_name.to_s.pluralize}\\.xml$}, 
-            proc { |post_body| Dupe.create(:#{model_name.to_s}, post_body) }
+            %r{^#{model_name.to_s.constantize.prefix rescue '/'}#{model_name.to_s.demodulize.downcase.pluralize}\\.xml$}, 
+            proc { |post_body| Dupe.create(:"#{model_name.to_s}", post_body) }
           )
           network.define_service_mock(
             :put,
-            %r{^#{model_name.to_s.titleize.constantize.prefix rescue '/'}#{model_name.to_s.pluralize}/(\\d+)\\.xml$}, 
-            proc { |id, put_data| Dupe.find(:#{model_name.to_s}) {|resource| resource.id == id.to_i}.merge!(put_data) }
+            %r{^#{model_name.to_s.constantize.prefix rescue '/'}#{model_name.to_s.demodulize.downcase.pluralize}/(\\d+)\\.xml$}, 
+            proc { |id, put_data| Dupe.find(:"#{model_name.to_s}") {|resource| resource.id == id.to_i}.merge!(put_data) }
           )
           network.define_service_mock(
             :delete,
-            %r{^#{model_name.to_s.titleize.constantize.prefix rescue '/'}#{model_name.to_s.pluralize}/(\\d+)\\.xml$}, 
-            proc { |id| Dupe.delete(:#{model_name.to_s}) {|resource| resource.id == id.to_i} }
+            %r{^#{model_name.to_s.constantize.prefix rescue '/'}#{model_name.to_s.demodulize.downcase.pluralize}/(\\d+)\\.xml$}, 
+            proc { |id| Dupe.delete(:"#{model_name.to_s}") {|resource| resource.id == id.to_i} }
           )
         }
+        
         eval(mocks)
       end
     end
@@ -260,7 +262,7 @@ class Dupe
     def create(model_name, records={})
       model_name = model_name.to_s.singularize.to_sym
       define model_name unless model_exists(model_name)
-      records = records.kind_of?(Array) ? records.map {|r| r.symbolize_keys} : records.symbolize_keys!    
+      records = records.kind_of?(Array) ? records.map {|r| r.symbolize_keys} : records.symbolize_keys!
       create_and_insert records, :into => model_name
     end
 
@@ -488,14 +490,13 @@ class Dupe
       ) if !into || !into.kind_of?(Hash) || !into[:into]
       
       # do we have several records to create, and are they each a hash?
-      if records.kind_of?(Array) and
-         records.inject(true) {|bool, r| bool and r.kind_of?(Hash)}
+      if records.kind_of?(Array) and records.inject(true) {|bool, r| bool and r.kind_of?(Hash)}
         [].tap do |results|
           records.each do |record| 
             results << models[into[:into]].create(record).tap {|r| database.insert r}
           end
         end
-      
+        
       # do we only have one record to create, and is it a hash?
       elsif records.kind_of?(Hash)
         models[into[:into]].create(records).tap {|r| database.insert r}

data/lib/superdupe/mock.rb

@@ -25,7 +25,6 @@ class Dupe
           StandardError, 
           "Tried to mock a response to a non-matched url! This should never occur. My pattern: #{@url_pattern}. Url: #{url}"
         ) unless match?(url)
-      
         grouped_results = url_pattern.match(url)[1..-1]
         grouped_results << body if body
         resp = @response.call *grouped_results
@@ -49,7 +48,12 @@ class Dupe
             raise ResourceNotFoundError, "Failed with 404: the request '#{url}' returned nil." 
             
           when Dupe::Database::Record
-            resp = resp.to_xml_safe(:root => resp.__model__.name.to_s)
+            # if a namespace is available, demodulize the modelname
+            if resp.__model__.name.to_s.include?('::')
+              resp = resp.to_xml_safe(:root => resp.__model__.name.to_s.demodulize)
+            else
+              resp = resp.to_xml_safe(:root => resp.__model__.name.to_s)
+            end
 
           when Array
             if resp.empty?

data/lib/superdupe/record.rb

@@ -21,7 +21,13 @@ class Dupe
       end
 
       def record_inspect
-        class_name = __model__ ? "Duped::#{__model__.name.to_s.titleize}" : self.class.to_s
+        # if a namespace is available, the titleize method destroy the scope operator
+        if class_name = __model__ 
+          __model__name.to_s.include?('::') ? "Duped::#{__model__.name.to_s}" : "Duped::#{__model__.name.to_s.titleize}"
+        else
+          self.class.to_s
+        end
+        
         "<##{class_name}".tap do |inspection|
           keys.each do |key|
             inspection << " #{key}=#{self[key].inspect}"

data/spec/lib_specs/active_resource_extensions_spec.rb

@@ -1,141 +1,105 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
-describe ActiveResource::Connection do 
-  before do
+class Customer < ActiveResource::Base
+  self.site = ''
+end
+
+describe Customer do
+  before(:each) do
     Dupe.reset
   end
   
-  describe "#get" do
-    before do
-      @book = Dupe.create :book, :title => 'Rooby', :label => 'rooby'
-      class Book < ActiveResource::Base
-        self.site = ''
-      end
+  it "should have none url patterns registered" do
+    [:post, :get, :delete, :put].each do |verb|
+      Dupe.network.mocks[verb].should be_blank
     end
-    
-    it "should pass a request off to the Dupe network if the original request failed" do            
-      Dupe.network.should_receive(:request).with(:get, '/books.xml').once.and_return(Dupe.find(:books).to_xml(:root => 'books'))
-      books = Book.find(:all)
+  end
+  
+  
+  context "registerd" do
+    before(:each) do
+      Dupe.create Customer, :name => 'Ribi', :state => 'active'
     end
-    
-    it "should parse the xml and turn the result into active resource objects" do
-      books = Book.find(:all)
-      books.length.should == 1
-      books.first.id.should == 1
-      books.first.title.should == 'Rooby'
-      books.first.label.should == 'rooby'
+  
+    it "should be registered as get mock" do
+      Dupe.network.mocks[:get].size == 2
     end
-  end
   
-  describe "#post" do
-    before do
-      @book = Dupe.create :book, :label => 'rooby', :title => 'Rooby'
-      @book.delete(:id)
-      class Book < ActiveResource::Base
-        self.site = ''
-      end
+    it "should generate a GetMock" do
+      customer = Dupe.find :"Customer"
+      customer.should_not be_nil
+      customer.class.should == Dupe::Database::Record
     end
     
-    it "should pass a request off to the Dupe network if the original request failed" do
-      Dupe.network.should_receive(:request).with(:post, '/books.xml', Hash.from_xml(@book.to_xml(:root => 'book'))["book"] ).once
-      book = Book.create({:label => 'rooby', :title => 'Rooby'})
+    it "should generate a valid url pattern" do
+      Dupe.network.mocks[:get].each_with_index do |mock, index|
+        mock.url_pattern.class.should == Regexp
+        if index == 0
+          mock.url_pattern.inspect.should == (%r{^\/customers\.xml$}).inspect
+        else
+          mock.url_pattern.inspect.should == %r{^\/customers\/(\d+)\.xml$}.inspect
+        end      
+      end
     end
     
-    it "should parse the xml and turn the result into active resource objects" do
-      book = Book.create({:label => 'rooby', :title => 'Rooby'})
-      book.id.should == 2
-      book.title.should == 'Rooby'
-      book.label.should == 'rooby'
-    end
     
-    it "should make ActiveResource throw an unprocessable entity exception if our Post mock throws a Dupe::UnprocessableEntity exception" do
-      Post %r{/books\.xml} do |post_data|
-        raise Dupe::UnprocessableEntity.new(:title => "must be present.") unless post_data["title"]
-        Dupe.create :book, post_data
-      end
+    context "find single resource" do
+      before(:each) { @customer = Customer.find 1 }
       
-      b = Book.create
-      b.new?.should be_true
-      b.errors.errors.should_not be_empty
-      b = Book.create(:title => "hello")
-      b.new?.should be_false
-      b.errors.should be_empty
-    end
-  end
-
-  describe "#put" do
-    before do
-      @book = Dupe.create :book, :label => 'rooby', :title => 'Rooby'
-      class Book < ActiveResource::Base
-        self.site = ''
+      it "should find customer with id 1" do
+        @customer.should_not be_blank
       end
-      @ar_book = Book.find(1)
     end
     
-    it "should pass a request off to the Dupe network if the original request failed" do
-      Dupe.network.should_receive(:request).with(:put, '/books/1.xml', Hash.from_xml(@book.merge(:title => "Rails!").to_xml(:root => 'book'))["book"].symbolize_keys!).once
-      @ar_book.title = 'Rails!'
-      @ar_book.save
-    end
-    
-    it "should parse the xml and turn the result into active resource objects" do
-      @book.title.should == "Rooby"
-      @ar_book.title = "Rails!"
-      @ar_book.save
-      @ar_book.new?.should == false
-      @ar_book.valid?.should == true
-      @ar_book.id.should == 1
-      @ar_book.label.should == "rooby"
-      @book.title.should == "Rails!"
-      @book.id.should == 1
-      @book.label.should == 'rooby'
-    end
     
-    it "should make ActiveResource throw an unprocessable entity exception if our Put mock throws a Dupe::UnprocessableEntity exception" do
-      Put %r{/books/(\d+)\.xml} do |id, put_data|
-        raise Dupe::UnprocessableEntity.new(:title => " must be present.") unless put_data[:title]
-        Dupe.find(:book) {|b| b.id == id.to_i}.merge!(put_data)
+    context "find every resource" do
+      before(:each) { @customers = Customer.find :all }
+      
+      it "should return an array" do
+        @customers.class.should == Array
       end
       
-      @ar_book.title = nil
-      @ar_book.save.should == false
-      @ar_book.errors.on_base.should_not be_empty
-
-      @ar_book.title = "Rails!"
-      @ar_book.save.should == true
-      # the following line should be true, were it not for a bug in active_resource 2.3.3 - 2.3.5
-      # i reported the bug here: https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/4169-activeresourcebasesave-put-doesnt-clear-out-errors
-      # @ar_book.errors.should be_empty
-    end
-  end
-
-  describe "#delete" do
-    before do
-      @book = Dupe.create :book, :label => 'rooby', :title => 'Rooby'
-      class Book < ActiveResource::Base
-        self.site = ''
+      it "should include customer number one" do
+        @customers.should be_include(Customer.find(1))
+      end
+      
+      it "should have size of one" do
+        @customers.size.should == 1
       end
-      @ar_book = Book.find(1)
     end
     
-    it "should pass a request off to the Dupe network if the original request failed" do
-      Dupe.network.should_receive(:request).with(:delete, '/books/1.xml').once
-      @ar_book.destroy
-    end
     
-    it "trigger a Dupe.delete to delete the mocked resource from the duped database" do
-      Dupe.find(:books).length.should == 1
-      @ar_book.destroy
-      Dupe.find(:books).length.should == 0
-    end
-
-    it "should allow you to override the default DELETE intercept mock" do
-      Delete %r{/books/(\d+)\.xml} do |id|
-        raise StandardError, "Testing Delete override"
+    context "find every resource with a param-filter" do
+      before(:each) do
+        Dupe.create Customer, :name => 'Marco', :state => 'inactive'
+        Get %r{\/customers\.xml\?state=(active|inactive)} do |state|
+          if state == 'active'
+            Dupe.find(:"Customers") {|customer| customer.state == 'active'}
+          elsif state == 'inactive'
+            Dupe.find(:"Customers") {|customer| customer.state == 'inactive'}
+          else
+            Dupe.find(:"Customers")
+          end
+        end
+      end
+      
+      it "should find all active customers" do
+        active_customers = Customer.find :all, :params => {:state => 'active'}
+        active_customers.size.should == 1
+        active_customers.should be_include(Customer.find(1))
+      end
+      
+      it "should find all inactive customers" do
+        inactive_customers = Customer.find :all, :params => {:state => 'inactive'}
+        inactive_customers.size.should == 1
+        inactive_customers.should be_include(Customer.find(2))
+      end
+      
+      it "should find all customers without a filter" do
+        customers = Customer.find :all, :params => {}
+        customers.size.should == 2
+        customers.should == Customer.find(:all)
       end
-
-      proc {@ar_book.destroy}.should raise_error(StandardError, "Testing Delete override")
     end
   end
-
-end
+end

data/spec/spec_helper.rb

@@ -5,4 +5,4 @@ gem 'rspec'
 gem 'cucumber'
 require 'cucumber'
 require 'active_resource'
-require 'dupe'
+require 'superdupe'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: superdupe
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: false
   segments: 
   - 0
-  - 4
+  - 5
   - 0
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Marco Ribi
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-02 00:00:00 +02:00
+date: 2010-09-10 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -70,22 +70,6 @@ files:
 - rails_generators/dupe/templates/definitions.rb
 - rails_generators/dupe/templates/load_dupe.rb
 - spec/lib_specs/active_resource_extensions_spec.rb
-- spec/lib_specs/attribute_template_spec.rb
-- spec/lib_specs/database_spec.rb
-- spec/lib_specs/dupe_spec.rb
-- spec/lib_specs/hash_pruner_spec.rb
-- spec/lib_specs/log_spec.rb
-- spec/lib_specs/logged_request_spec.rb
-- spec/lib_specs/mock_definitions_spec.rb
-- spec/lib_specs/mock_spec.rb
-- spec/lib_specs/model_spec.rb
-- spec/lib_specs/network_spec.rb
-- spec/lib_specs/record_spec.rb
-- spec/lib_specs/rest_validation_spec.rb
-- spec/lib_specs/schema_spec.rb
-- spec/lib_specs/sequence_spec.rb
-- spec/lib_specs/string_spec.rb
-- spec/lib_specs/symbol_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/screenconcept/dupe
@@ -123,20 +107,4 @@ specification_version: 3
 summary: A tool that helps you mock services while cuking.
 test_files: 
 - spec/lib_specs/active_resource_extensions_spec.rb
-- spec/lib_specs/attribute_template_spec.rb
-- spec/lib_specs/database_spec.rb
-- spec/lib_specs/dupe_spec.rb
-- spec/lib_specs/hash_pruner_spec.rb
-- spec/lib_specs/log_spec.rb
-- spec/lib_specs/logged_request_spec.rb
-- spec/lib_specs/mock_definitions_spec.rb
-- spec/lib_specs/mock_spec.rb
-- spec/lib_specs/model_spec.rb
-- spec/lib_specs/network_spec.rb
-- spec/lib_specs/record_spec.rb
-- spec/lib_specs/rest_validation_spec.rb
-- spec/lib_specs/schema_spec.rb
-- spec/lib_specs/sequence_spec.rb
-- spec/lib_specs/string_spec.rb
-- spec/lib_specs/symbol_spec.rb
 - spec/spec_helper.rb

data/spec/lib_specs/attribute_template_spec.rb

@@ -1,173 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Dupe::Model::Schema::AttributeTemplate do 
-  describe "new" do
-    it "should require a name" do
-      proc {
-        Dupe::Model::Schema::AttributeTemplate.new
-      }.should raise_error(ArgumentError)
-    end
-    
-    it "should set the name if one is passed to it" do
-      attribute = Dupe::Model::Schema::AttributeTemplate.new(:title)
-      attribute.name.should == :title
-    end
-    
-    it "should set a default value if one is passed to it" do
-      attribute = 
-        Dupe::Model::Schema::AttributeTemplate.new(
-          :title, 
-          :default => 'Untitled'
-        )
-      attribute.default.should == 'Untitled'
-    end
-    
-    it "should verify that the transformer is a proc" do
-      proc {
-        attribute = 
-          Dupe::Model::Schema::AttributeTemplate.new(
-            :title, 
-            :default => nil, 
-            :transformer => 'not a proc'
-          )
-      }.should raise_error(
-        ArgumentError,
-        "Your transformer must be a kind of proc."
-      )
-    end
-    
-    it "should verify that the transformer requires a single parameter" do
-      proc {
-        attribute = Dupe::Model::Schema::AttributeTemplate.new(
-          :title, 
-          :default => nil, 
-          :transformer => proc {'test'}
-        )
-      }.should raise_error(
-        ArgumentError,
-        "Your transformer must accept a parameter."
-      )
-    end
-    
-    it "should set the transformer if one is passed" do
-      transformer = proc {|dont_care| }
-      attribute = Dupe::Model::Schema::AttributeTemplate.new(
-        :title, 
-        :default => nil, 
-        :transformer => transformer
-      )
-      attribute.transformer.should == transformer
-    end
-  end
-  
-  describe "generate" do
-    describe "on an attribute without a default value and without a transformer" do
-      before do
-        @attribute = Dupe::Model::Schema::AttributeTemplate.new(:title)
-      end
-
-      it "should generate a key with the name of the attribute" do
-        key, value = @attribute.generate
-        key.should == @attribute.name
-      end
-      
-      describe "when passed nothing" do     
-        it "should generate a nil value" do
-          key, value = @attribute.generate
-          value.should == nil
-        end
-      end
-      
-      describe "when passed a value" do
-        it "should generate a value equal to the value passed in" do
-          key, value = @attribute.generate('test')
-          value.should == 'test'
-        end
-      end
-    end
-    
-    describe "on an attribute with a default value but without a transformer" do
-      before do
-        @attribute = Dupe::Model::Schema::AttributeTemplate.new(:title, :default => 'Untitled')
-      end
-
-      it "should generate a key with the name of the attribute" do
-        key, value = @attribute.generate
-        key.should == @attribute.name
-      end   
-      
-      describe "when passed nothing" do
-        it "should generate a value equal to the default value" do
-          key, value = @attribute.generate
-          value.should == @attribute.default
-        end
-      end
-      
-      describe "when passed a value" do
-        it "should generate a value equal to the value passed in" do
-          title = '2001: A Space Odyssey'
-          key, value = @attribute.generate title
-          value.should == title
-        end
-      end
-    end
-    
-    describe "on an attribute with a default value that is a proc" do
-      before do
-        @default_value = proc { 'knock' * 3 }
-        @attribute = Dupe::Model::Schema::AttributeTemplate.new(:title, :default => @default_value)
-      end
-
-      it "should generate a key with the name of the attribute" do
-        key, value = @attribute.generate
-        key.should == @attribute.name
-      end   
-      
-      describe "when passed nothing" do
-        it "should return the value of the default_value proc" do
-          key, value = @attribute.generate
-          value.should == @default_value.call
-        end
-      end
-      
-      describe "when passed a value" do
-        it "should generate a value equal to the value passed in" do
-          title = 'Rooby'
-          key, value = @attribute.generate title
-          value.should == title
-        end
-      end
-      
-    end
-    
-    describe "on an attribute with a transformer" do
-      before do
-        @transformer = proc {|dont_care| 'test'}
-        @attribute = Dupe::Model::Schema::AttributeTemplate.new(
-          :title, 
-          :default => nil, 
-          :transformer => @transformer
-        )
-      end
-      
-      it "should generate a key with the name of the attribute" do
-        key, value = @attribute.generate
-        key.should == @attribute.name
-      end
-      
-      describe "when passed nothing" do
-        it "should generate a value equal to the default" do
-          key, value = @attribute.generate
-          value.should == @attribute.default
-        end
-      end
-      
-      describe "when passed a value" do
-        it "should generate a value equal to the value returned by the transformer" do
-          key, value = @attribute.generate 'blah'
-          value.should == @transformer.call('blah')
-        end
-      end
-    end
-  end
-end