superdupe 0.4.0

data/lib/superdupe/mock.rb

@@ -0,0 +1,127 @@
+class Dupe
+  class Network #:nodoc:
+    class Mock #:nodoc:
+      class ResourceNotFoundError < StandardError; end
+      
+      attr_reader :url_pattern
+      attr_reader :response
+    
+      def initialize(url_pattern, response_proc=nil)
+        raise(
+          ArgumentError,
+          "The URL pattern parameter must be a type of regular expression."
+        ) unless url_pattern.kind_of?(Regexp)
+            
+        @response = response_proc || proc {}
+        @url_pattern = url_pattern
+      end
+    
+      def match?(url)
+        url_pattern =~ url ? true : false
+      end
+    
+      def mocked_response(url, body = nil)
+        raise(
+          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
+        process_response(resp, url)
+      end
+      
+      def process_response(resp, url)
+        raise NotImplementedError, "When you extend Dupe::Network::Mock, you must implement the #process_response instance method."
+      end
+    end
+  end
+end
+
+class Dupe
+  class Network
+    class GetMock < Mock #:nodoc:
+      def process_response(resp, url)
+        case resp
+          
+          when NilClass
+            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)
+
+          when Array
+            if resp.empty?
+              resp = [].to_xml :root => 'results'
+            else
+              resp = resp.map {|r| HashPruner.prune(r)}.to_xml(:root => resp.first.__model__.name.to_s.pluralize)
+            end
+        end
+        Dupe.network.log.add_request :get, url, resp
+        resp
+      end
+    end
+  end
+end
+
+class Dupe
+  class Network
+    class PostMock < Mock #:nodoc:
+      
+      # returns a tuple representing the xml of the processed entity, plus the url to the entity. 
+      def process_response(resp, url)
+        case resp
+          
+          when NilClass
+            raise StandardError, "Failed with 500: the request '#{url}' returned nil." 
+          
+          when Dupe::Database::Record
+            new_path = "/#{resp.__model__.name.to_s.pluralize}/#{resp.id}.xml"
+            resp = resp.to_xml_safe(:root => resp.__model__.name.to_s)
+            Dupe.network.log.add_request :post, url, resp
+            return resp, new_path
+          
+          else
+            raise StandardError, "Unknown PostMock Response. Your Post intercept mocks must return a Duped resource object or nil"
+        end
+      end
+    end
+  end
+end
+
+class Dupe
+  class Network
+    class PutMock < Mock #:nodoc:
+      
+      # returns a tuple representing the xml of the processed entity, plus the url to the entity. 
+      def process_response(resp, url)
+        case resp
+          
+          when NilClass
+            raise StandardError, "Failed with 500: the request '#{url}' returned nil." 
+          
+          when Dupe::Database::Record
+            resp = nil
+            Dupe.network.log.add_request :put, url, ""
+            return resp, url
+          
+          else
+            raise StandardError, "Unknown PutMock Response. Your Post intercept mocks must return a Duped resource object or nil"
+        end
+      end
+    end
+  end
+end
+
+class Dupe
+  class Network
+    class DeleteMock < Mock #:nodoc:
+      # logs the request 
+      def process_response(resp, url)
+        Dupe.network.log.add_request :delete, url, ""
+        nil
+      end
+    end
+  end
+end

data/lib/superdupe/model.rb

@@ -0,0 +1,59 @@
+class Dupe
+  class Model #:nodoc:
+    attr_reader :schema
+    attr_reader :name
+    attr_reader :id_sequence
+    
+    def initialize(name)
+      @schema = Dupe::Model::Schema.new
+      @name   = name.to_sym
+      @id_sequence = Sequence.new
+    end
+    
+    def define(definition_proc)
+      definition_proc.call @schema
+    end
+    
+    def create(attributes={})
+      Database::Record.new.tap do |record|
+        record.__model__ = self
+        record.id = @id_sequence.next
+        record.merge! default_record
+        record.merge! transform(attributes)
+      end
+    end
+    
+    # called by the Dupe::Database#insert method
+    def run_after_create_callbacks(record)
+      @schema.after_create_callbacks.each do |callback|
+        callback.call record
+      end
+    end
+    
+    private
+    def default_record
+      Database::Record.new.tap do |record|
+        # setup all the required attributes
+        @schema.attribute_templates.each do |attribute_template_name, attribute_template|
+          required_attribute_name, required_attribute_value = 
+            attribute_template.generate
+          record[required_attribute_name] = required_attribute_value
+        end
+      end
+    end
+    
+    def transform(attributes)
+      Database::Record.new.tap do |record|
+        # override the required attributes or create new attributes
+        attributes.each do |attribute_name, attribute_value|
+          if @schema.attribute_templates[attribute_name]
+            k, v = @schema.attribute_templates[attribute_name].generate attribute_value
+            record[attribute_name] = v
+          else
+            record[attribute_name] = attribute_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/superdupe/network.rb

@@ -0,0 +1,56 @@
+class Dupe
+  class Network    #:nodoc:
+    include RestValidation #:nodoc:
+    
+    class RequestNotFoundError < StandardError; end #:nodoc:
+    
+    attr_reader :mocks, :log
+    
+    def initialize
+      @mocks = {}
+      @log = Dupe::Network::Log.new
+      VERBS.each { |verb| @mocks[verb] = [] }
+    end
+        
+    def request(verb, url, body=nil)
+      validate_request_type verb
+      match(verb, url).mocked_response(url, body)
+    end
+    
+    def define_service_mock(verb, url_pattern, response_proc=nil)
+      validate_request_type verb
+      case verb
+      when :get
+        GetMock.new(url_pattern, response_proc).tap do |mock|
+          @mocks[verb] << mock
+        end
+      when :post
+        PostMock.new(url_pattern, response_proc).tap do |mock|
+          @mocks[verb].unshift mock
+        end
+      when :put
+        PutMock.new(url_pattern, response_proc).tap do |mock|
+          @mocks[verb].unshift mock
+        end
+      when :delete
+        DeleteMock.new(url_pattern, response_proc).tap do |mock|
+          @mocks[verb].unshift mock
+        end
+      else
+        raise StandardError, "Dupe does not support mocking #{verb.to_s.upcase} requests."
+      end
+    end
+    
+    private
+    def match(verb, url)
+      @mocks[verb].each do |mock|
+        return mock if mock.match?(url)
+      end
+      raise(
+        RequestNotFoundError,
+        "No mocked service response found for '#{url}'"
+      )
+    end
+    
+  end
+end

data/lib/superdupe/record.rb

@@ -0,0 +1,42 @@
+class Dupe
+  class Database #:nodoc:
+    class Record < Hash #:nodoc:
+      attr_accessor :__model__
+      
+      def id
+        self[:id]
+      end
+      
+      def id=(value)
+        self[:id] = value
+      end
+      
+      def method_missing(method_name, *args, &block)
+        if attempting_to_assign(method_name)
+          method_name = method_name.to_s[0..-2].to_sym
+          self[method_name] = args.first
+        else
+          self[method_name.to_sym]
+        end
+      end
+
+      def record_inspect
+        class_name = __model__ ? "Duped::#{__model__.name.to_s.titleize}" : self.class.to_s
+        "<##{class_name}".tap do |inspection|
+          keys.each do |key|
+            inspection << " #{key}=#{self[key].inspect}"
+          end
+          inspection << ">"
+        end
+      end
+      
+      alias_method :hash_inspect, :inspect
+      alias_method :inspect, :record_inspect
+      
+      private
+      def attempting_to_assign(method_name)
+        method_name.to_s[-1..-1] == '=' 
+      end
+    end
+  end
+end

data/lib/superdupe/rest_validation.rb

@@ -0,0 +1,16 @@
+class Dupe
+  class Network #:nodoc:
+    #:nodoc:
+    class UnknownRestVerbError < StandardError; end #:nodoc:
+    VERBS = [:get, :post, :put, :delete] #:nodoc:
+    
+    module RestValidation  #:nodoc:
+      def validate_request_type(verb)
+        raise(
+          Dupe::Network::UnknownRestVerbError,
+          "Unknown REST verb ':#{verb}'. Valid REST verbs are :get, :post, :put, and :delete."
+        ) unless Dupe::Network::VERBS.include?(verb)
+      end
+    end
+  end
+end

data/lib/superdupe/schema.rb

@@ -0,0 +1,52 @@
+class Dupe
+  class Model #:nodoc:
+    class Schema #:nodoc:
+      attr_reader :attribute_templates
+      attr_reader :after_create_callbacks
+      
+      def initialize
+        @attribute_templates = {}
+        @after_create_callbacks = []
+      end
+      
+      def method_missing(method_name, *args, &block)
+        attribute_name = method_name.to_s[-1..-1] == '=' ? method_name.to_s[0..-2].to_sym : method_name
+        if block && block.arity < 1
+          default_value = block
+          transformer = nil
+        else
+          default_value = args[0]
+          transformer = block
+        end
+        
+        @attribute_templates[method_name.to_sym] = 
+          AttributeTemplate.new method_name.to_sym, :default => default_value, :transformer => transformer
+      end
+      
+      def after_create(&block)
+        raise(
+          ArgumentError, 
+          "You must pass a block that accepts a single parameter to 'after_create'"
+        ) if !block || block.arity != 1
+        
+        @after_create_callbacks << block
+      end
+
+      def uniquify(*args)
+        raise ArgumentError, "You must pass at least one attribute to uniquify." if args.empty?
+        raise ArgumentError, "You may only pass symbols to uniquify." unless all_members_of_class(args, Symbol)
+
+        args.each do |attribute|
+          after_create do |record|
+            record[attribute] = "#{record.__model__.name} #{record.id} #{attribute}" unless record[attribute]
+          end
+        end
+      end
+
+      private
+      def all_members_of_class(ary, klass)
+        ary.inject(true) {|bool, v| bool && v.kind_of?(klass)}
+      end
+    end
+  end
+end

data/lib/superdupe/sequence.rb

@@ -0,0 +1,20 @@
+class Sequence #:nodoc:
+  attr_reader :current_value 
+  
+  def initialize(starting_at=1, sequencer=nil)
+    @current_value = starting_at
+    if sequencer && sequencer.arity != 1
+      raise ArgumentError, "Your block must accept a single parameter"
+    end
+    @transformer = sequencer
+  end
+  
+  def next
+    @current_value += 1
+    if @transformer
+      @transformer.call(@current_value - 1)
+    else
+      @current_value - 1
+    end
+  end
+end

data/lib/superdupe/singular_plural_detection.rb

@@ -0,0 +1,9 @@
+module SingularPluralDetection #:nodoc:
+  def singular?
+    self.to_s.singularize == self.to_s
+  end
+  
+  def plural?
+    self.to_s.pluralize == self.to_s
+  end
+end

data/lib/superdupe/string.rb

@@ -0,0 +1,7 @@
+class String #:nodoc:
+  include SingularPluralDetection
+  
+  def indent(spaces=2)
+    split("\n").map {|l| (" " * spaces) + l }.join("\n")
+  end
+end

data/lib/superdupe/symbol.rb

@@ -0,0 +1,3 @@
+class Symbol #:nodoc:
+  include SingularPluralDetection
+end

data/lib/superdupe.rb

@@ -0,0 +1,20 @@
+require 'superdupe/hash_pruner'
+require 'active_resource'
+require 'active_resource/http_mock'
+require 'superdupe/singular_plural_detection'
+require 'superdupe/symbol'
+require 'superdupe/string'
+require 'superdupe/rest_validation'
+require 'superdupe/mock'
+require 'superdupe/log'
+require 'superdupe/network'
+require 'superdupe/dupe'
+require 'superdupe/database'
+require 'superdupe/sequence'
+require 'superdupe/record'
+require 'superdupe/attribute_template'
+require 'superdupe/schema'
+require 'superdupe/model'
+require 'superdupe/custom_mocks'
+require 'superdupe/active_resource_extensions'
+require 'superdupe/cucumber_hooks'

data/rails_generators/dupe/dupe_generator.rb

@@ -0,0 +1,20 @@
+class DupeGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      # make sure the features and features/support directories exist
+      m.directory 'features/support'
+      m.directory 'features/dupe'
+      m.directory 'features/dupe/custom_mocks'
+      m.directory 'features/dupe/definitions'
+
+      # copy the custom_mocks.rb example file into features/dupe/custom_mocks
+      m.template 'custom_mocks.rb', 'features/dupe/custom_mocks/custom_mocks.rb'
+
+      # copy the definitions.rb example file into features/dupe/definitions
+      m.template 'definitions.rb', 'features/dupe/definitions/definitions.rb'
+      
+      # copy the load_dupe.rb into the features/support directory
+      m.template 'load_dupe.rb', 'features/support/load_dupe.rb'
+    end
+  end
+end

data/rails_generators/dupe/templates/custom_mocks.rb

@@ -0,0 +1,4 @@
+# Example:
+# Get %r{/books/([\d\w-]+)\.xml} do |label|
+#   Dupe.find(:book) {|b| b.label == label}
+# end

data/rails_generators/dupe/templates/definitions.rb

@@ -0,0 +1,9 @@
+# set this to false if you don't care to see the requests mocked 
+# for each cucumber scenario.
+Dupe.debug = true
+
+
+# Define your models
+# Dupe.define :example_model do |attrs|
+#   attrs.example_attribute 'Example Default Value'
+# end

data/rails_generators/dupe/templates/load_dupe.rb

@@ -0,0 +1,9 @@
+# First, load the definitions
+Dir[File.join(File.dirname(__FILE__), '../dupe/definitions/*.rb')].each do |file|
+  require file
+end
+
+# next, load the custom mocks
+Dir[File.join(File.dirname(__FILE__), '../dupe/custom_mocks/*.rb')].each do |file|
+  require file
+end

data/spec/lib_specs/active_resource_extensions_spec.rb

@@ -0,0 +1,141 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ActiveResource::Connection do 
+  before do
+    Dupe.reset
+  end
+  
+  describe "#get" do
+    before do
+      @book = Dupe.create :book, :title => 'Rooby', :label => 'rooby'
+      class Book < ActiveResource::Base
+        self.site = ''
+      end
+    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
+    
+    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'
+    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
+    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'})
+    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
+      
+      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 = ''
+      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)
+      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 = ''
+      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"
+      end
+
+      proc {@ar_book.destroy}.should raise_error(StandardError, "Testing Delete override")
+    end
+  end
+
+end