dupe 0.3.7 → 0.4.0

data/spec/lib_specs/logged_request_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Network::Log::Request do
+  describe "##new" do
+    it "should set the verb, url, and response_body" do
+      r = Dupe::Network::Log::Request.new :get, "/knock-knock", "who's there?"
+      r.verb.should == :get
+      r.path.should == "/knock-knock"
+      r.response_body.should == "who's there?"
+    end
+  end
+  
+  describe "#pretty_print" do
+    it "should show the request type, request path, and request response" do
+      r = Dupe::Network::Log::Request.new :get, "/knock-knock", "who's there?"
+      r.pretty_print.should ==
+        "Request: GET /knock-knock\n" +
+        "Response:\n" +
+        "  who's there?"
+    end
+  end
+end

data/spec/lib_specs/mock_definitions_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Mock Definition Methods" do
+  before do
+    Dupe.reset
+  end
+  
+  describe "Get" do    
+    it "should require a url pattern that is a regex" do
+      proc { Get() }.should raise_error(ArgumentError)
+      proc { Get 'not a regexp' }.should raise_error(ArgumentError)
+      proc { Get %r{/some_url} }.should_not raise_error
+    end
+    
+    it "should create and return a Dupe::Network::Mock of type :get" do
+      Dupe.network.mocks[:get].should be_empty
+      @book = Dupe.create :book, :label => 'rooby'
+      Dupe.network.mocks[:get].should_not be_empty
+      Dupe.network.mocks[:get].length.should == 2
+      
+      mock = Get %r{/books/([^&]+)\.xml} do |label|
+        Dupe.find(:book) {|b| b.label == label}
+      end
+      
+      Dupe.network.mocks[:get].length.should == 3
+      Dupe.network.mocks[:get].last.should == mock
+      Dupe.network.mocks[:get].last.url_pattern.should == %r{/books/([^&]+)\.xml}
+      book = Dupe.find(:book)
+      Dupe.network.request(:get, '/books/rooby.xml').should == book.to_xml(:root => 'book')
+    end
+  end
+end

data/spec/lib_specs/mock_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Network::Mock do
+  before do
+    Dupe.reset
+  end
+  
+  describe "new" do
+    it "should require a valid REST type" do
+      proc { Dupe::Network::Mock.new :unknown, /\//, proc {} }.should raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { Dupe::Network::Mock.new :get,     /\//, proc {} }.should_not raise_error
+      proc { Dupe::Network::Mock.new :post,    /\//, proc {} }.should_not raise_error
+      proc { Dupe::Network::Mock.new :put,     /\//, proc {} }.should_not raise_error
+      proc { Dupe::Network::Mock.new :delete,  /\//, proc {} }.should_not raise_error
+    end
+    
+    it "should require the url be a kind of regular expression" do
+      proc { Dupe::Network::Mock.new :get, '', proc {} }.should raise_error(
+        ArgumentError,
+        "The URL pattern parameter must be a type of regular expression."
+      )
+    end
+    
+    it "should set the @verb, @url, and @response parameters accordingly" do
+      url_pattern = /\//
+      response = proc {}
+      mock = Dupe::Network::Mock.new :get, url_pattern, response
+      mock.verb.should == :get
+      mock.url_pattern.should == url_pattern
+      mock.response.should == response
+    end
+  end
+  
+  describe "match?" do
+    it "should determine if a given string matches the mock's url pattern" do
+      url = %r{/blogs/(\d+).xml}
+      response = proc {}
+      mock = Dupe::Network::Mock.new :get, url, response
+      mock.match?('/blogs/1.xml').should == true
+      mock.match?('/bogs/1.xml').should == false
+    end
+  end
+  
+  describe "mocked_response" do
+    describe "on a mock object whose response returns a Dupe.find" do
+      it "should convert the response result to xml" do
+        url_pattern = %r{/books/(\d+)\.xml}
+        response = proc {|id| Dupe.find(:book) {|b| b.id == id.to_i}}
+        book = Dupe.create :book
+        mock = Dupe::Network::Mock.new :get, url_pattern, response
+        mock.mocked_response('/books/1.xml').should == book.to_xml(:root => 'book')
+      end
+      
+      it "should add a request to the Dupe::Network#log" do
+        url_pattern = %r{/books/([a-zA-Z0-9-]+)\.xml}
+        response = proc {|label| Dupe.find(:book) {|b| b.label == label}}
+        book = Dupe.create :book, :label => 'rooby'
+        mock = Dupe::Network::Mock.new :get, url_pattern, response
+        Dupe.network.log.requests.length.should == 0
+        mock.mocked_response('/books/rooby.xml')
+        Dupe.network.log.requests.length.should == 1
+      end
+    end
+  end
+  
+  
+end

data/spec/lib_specs/model_spec.rb

@@ -0,0 +1,90 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Model do
+  describe "new" do
+    it "should require a model name" do
+      proc { Dupe::Model.new }.should raise_error(ArgumentError)
+    end
+    
+    it "should set the model name to what was passed in during initialization" do
+      m = Dupe::Model.new :book
+      m.name.should == :book
+    end
+    
+    it "should initialize an empty schema" do
+      m = Dupe::Model.new :book
+      m.schema.should be_kind_of(Dupe::Model::Schema)
+    end
+    
+    it "should setup an id_sequence initialized to 0" do
+      m = Dupe::Model.new :book
+      m.id_sequence.current_value.should == 1
+    end
+  end
+  
+  describe "define" do
+    describe "when passed a proc" do
+      before do
+        @model = Dupe::Model.new :book
+        @definition = proc { |attrs|
+          attrs.author('Anonymous') do |dont_care|
+            'Flying Spaghetti Monster'
+          end
+        }
+      end
+      
+      it "should pass that proc off to it's schema" do
+        @model.schema.should_receive(:method_missing).once
+        @model.define @definition
+      end
+      
+      it "should result in a schema with the desired attribute templates" do
+        @model.define @definition
+        @model.schema.attribute_templates[:author].name.should == :author
+        @model.schema.attribute_templates[:author].default.should == 'Anonymous'
+        @model.schema.attribute_templates[:author].transformer.call(
+          'dont care'
+        ).should == 'Flying Spaghetti Monster'
+      end
+    end
+  end
+  
+  describe "create" do
+    before do 
+      Dupe.define :book do |attrs|
+        attrs.title 'Untitled'
+        attrs.author 'Anon' do |author|
+          "Author: #{author}"
+        end
+        attrs.after_create do |book|
+          book.label = book.title.downcase.gsub(/\ +/, '-')
+        end
+      end
+      
+      @book_model = Dupe.models[:book]
+    end
+    
+    it "shouldn't require any parameters" do
+      proc {
+        @book_model.create
+      }.should_not raise_error
+    end
+    
+    it "should return a Dupe::Database::Record instance with the desired parameters" do
+      book = @book_model.create
+      book.should be_kind_of(Dupe::Database::Record)
+      book.__model__.name.should == :book
+      book.id.should == 1
+      book.title.should == 'Untitled'
+      book.author.should == 'Anon'
+      book.label.should == 'untitled'
+      
+      book = @book_model.create :title => 'Rooby On Rails', :author => 'Matt Parker'
+      book.__model__.name.should == :book
+      book.id.should == 2
+      book.title.should == 'Rooby On Rails'
+      book.label.should == 'rooby-on-rails'
+      book.author.should == 'Author: Matt Parker'
+    end
+  end
+end

data/spec/lib_specs/network_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Network do
+  
+  describe "new" do
+    before do
+      @network = Dupe::Network.new
+    end
+    
+    it "should initialize @mocks to a hash of empty arrays keyed with valid REST verbs" do
+      Dupe::Network::VERBS.each do |verb|
+        @network.mocks[verb].should == []
+      end
+    end
+    
+    it "should initialize @log to a new Dupe::Network::Log" do
+      @network.log.should be_kind_of(Dupe::Network::Log)
+    end
+  end
+  
+  describe "request" do
+    before do
+      @network = Dupe::Network.new
+    end
+    
+    it "should require a valid REST verb" do
+      proc { @network.request }.should raise_error
+      proc { @network.request :invalid_rest_verb, '/some_url' }.should raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { @network.request :get, '/some_url' }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+    end
+    
+    it "should require a URL" do
+      proc { @network.request :get }.should raise_error(ArgumentError)
+      proc { @network.request :get, 'some_url'}.should_not raise_error(ArgumentError)
+    end
+    
+    it "should raise an exception if the network has no mocks that match the url" do
+      proc { @network.request(:get, '/some_url')}.should raise_error(Dupe::Network::RequestNotFoundError)
+    end
+    
+    it "should return the appropriate mock response if a mock matches the url" do
+      @network.define_service_mock :get, %r{/greeting$}, proc { "hello" }
+      @network.request(:get, '/greeting').should == 'hello'
+    end
+  end
+  
+  describe "define_service_mock" do
+    before do
+      @network = Dupe::Network.new
+    end
+    
+    it "should require a valid REST verb" do
+      proc { @network.define_service_mock }.should raise_error
+      proc { @network.define_service_mock :invalid_rest_verb, // }.should raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { @network.define_service_mock :get, // }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+    end
+    
+    it "should require a valid Regexp url pattern" do
+      proc { @network.define_service_mock :get, 'not a regular expression' }.should raise_error(ArgumentError)
+      proc { @network.define_service_mock :get, // }.should_not raise_error
+    end
+    
+    it "should create and return a new service mock when given valid parameters" do
+      verb = :get
+      pattern = //
+      response = proc { 'test' }
+      @network.mocks[:get].should be_empty
+      mock = @network.define_service_mock verb, pattern, response
+      @network.mocks[:get].should_not be_empty
+      @network.mocks[:get].length.should == 1
+      @network.mocks[:get].first.should == mock
+    end
+    
+    
+  end
+  
+end

data/spec/lib_specs/record_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Database::Record do
+  describe "new" do
+    it "should create an object that is a kind of Hash" do
+      Dupe::Database::Record.new.should be_kind_of(Hash)
+    end
+  end
+  
+  describe "id" do
+    it "should allow us to set the record id (and not the object id)" do
+      d = Dupe::Database::Record.new
+      d.id.should == nil
+      d[:id].should == nil
+      d.id = 1
+      d.id.should == 1
+      d[:id].should == 1
+    end
+  end
+  
+  describe "method_missing" do
+    it "should allow us to access hash keys as if they were object attributes" do
+      d = Dupe::Database::Record.new
+      d[:some_key].should == nil
+      d.some_key.should == nil
+      d.some_key = 1
+      d.some_key.should == 1
+      d[:some_key].should == 1
+      d[:another_key] = 2
+      d.another_key.should == 2
+      d[:another_key].should == 2
+    end
+  end
+  
+  describe "inspect" do
+    it "should show the class name" do
+      d = Dupe::Database::Record.new
+      d.inspect.should match(/^<#Dupe::Database::Record/)
+    end
+    
+    it "should show the key/value pairs as attributes" do
+      d = Dupe::Database::Record.new 
+      d.title = 'test'
+      d.inspect.should match(/title="test"/)
+      d.author = Dupe::Database::Record.new
+      d.inspect.should match(/author=<#Dupe::Database::Record/)
+    end
+    
+    it "should show Fake::<model_name> when the record has a model" do
+      b = Dupe.create :book
+      b.inspect.should match(/^<#Duped::Book/)
+      b.author = Dupe.create :author
+      b.inspect.should match(/^<#Duped::Book/)
+      b.inspect.should match(/author=<#Duped::Author/)
+    end
+  end
+  
+  describe "__model__" do  
+    it "should have a __model__ instance variable" do
+      proc {Dupe::Database::Record.new.__model__}.should_not raise_error
+    end
+    
+    it "should all you to set the __model_name__ instance variable" do
+      r = Dupe::Database::Record.new
+      proc {r.__model__ = :book}.should_not raise_error
+      r.__model__.should == :book
+    end
+  end
+  
+end

data/spec/lib_specs/rest_validation_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Network::RestValidation do
+  before do
+    class TestRestValidation
+      include Dupe::Network::RestValidation
+    end
+  end
+  
+  describe "validate_request_type" do
+    it "should raise an exception if the request type isn't :get, :post, :put, or :delete" do
+      proc { 
+        TestRestValidation.new.validate_request_type(:unknown_request_type) 
+      }.should raise_error(Dupe::Network::UnknownRestVerbError)
+    end
+  end
+end

data/spec/lib_specs/schema_spec.rb

@@ -0,0 +1,90 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Model::Schema do
+  describe "new" do
+    it "should initialize attribute_templates to an empty hash" do
+      Dupe::Model::Schema.new.attribute_templates.should == {}
+    end
+    
+    it "should initialize after_create_callbacks to an empty array" do
+      Dupe::Model::Schema.new.after_create_callbacks.should == []
+    end
+  end
+  
+  describe "dynamic attribute_template creation methods" do
+    before do
+      @schema = Dupe::Model::Schema.new
+    end
+    
+    describe "called with no parameters" do
+      it "should create a new attribute template with no transformer and no default value" do
+        @schema.title
+        @schema.attribute_templates[:title].should be_kind_of(Dupe::Model::Schema::AttributeTemplate)
+        @schema.attribute_templates[:title].name.should == :title
+        @schema.attribute_templates[:title].default.should be_nil
+        @schema.attribute_templates[:title].transformer.should be_nil
+      end
+    end
+    
+    describe "called with a single parameter, but no block" do
+      it "should create a new attribute template with a default value but no transformer" do
+        @schema.title 'Untitled'
+        @schema.attribute_templates[:title].should be_kind_of(Dupe::Model::Schema::AttributeTemplate)
+        @schema.attribute_templates[:title].name.should == :title
+        @schema.attribute_templates[:title].default.should == 'Untitled'
+        @schema.attribute_templates[:title].transformer.should be_nil
+      end
+    end
+    
+    describe "called with a block that accepts a parameter" do
+      it "should create a new attribute template without a default value, but with a tranformer" do
+        @schema.title {|dont_care| 'test'}
+        @schema.attribute_templates[:title].should be_kind_of(Dupe::Model::Schema::AttributeTemplate)
+        @schema.attribute_templates[:title].name.should == :title
+        @schema.attribute_templates[:title].default.should be_nil
+        @schema.attribute_templates[:title].transformer.should be_kind_of(Proc)
+      end
+    end
+    
+    describe "called with a block that doesn't accept a parameter" do
+      it "should create a new attribute template without a transformer, and with the block as the default value" do
+        @schema.title { 'knock' * 3 }
+        @schema.attribute_templates[:title].should be_kind_of(Dupe::Model::Schema::AttributeTemplate)
+        @schema.attribute_templates[:title].name.should == :title
+        @schema.attribute_templates[:title].default.should be_kind_of(Proc)
+        @schema.attribute_templates[:title].default.call.should == "knockknockknock"
+        @schema.attribute_templates[:title].transformer.should be_nil
+      end
+    end
+    
+    describe "called with a block and a parameter" do
+      it "should create a new attribute template with a default value AND with a tranformer" do
+        @schema.title('Untitled') {|dont_care| 'test'}
+        @schema.attribute_templates[:title].should be_kind_of(Dupe::Model::Schema::AttributeTemplate)
+        @schema.attribute_templates[:title].name.should == :title
+        @schema.attribute_templates[:title].default.should == 'Untitled'
+        @schema.attribute_templates[:title].transformer.should be_kind_of(Proc)
+      end
+    end
+  end
+  
+  describe "#after_create" do
+    before do
+      @schema = Dupe::Model::Schema.new
+    end
+    
+    it "should require a block that accepts a single parameter" do
+      proc { @schema.after_create }.should raise_error(ArgumentError)
+      proc { @schema.after_create { "parameterless block" } }.should raise_error(ArgumentError)
+      proc { @schema.after_create {|s| s.title = 'test' } }.should_not raise_error
+    end
+    
+    it "should add the callback to the list of after_create_callbacks" do
+      @schema.after_create_callbacks.should be_empty
+      @schema.after_create {|s| s.title = 'test'}
+      @schema.after_create_callbacks.length.should == 1
+      @schema.after_create_callbacks.first.should be_kind_of(Proc)
+    end
+    
+  end
+end

data/spec/lib_specs/sequence_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Sequence do
+  describe "new" do    
+    it "should intialize the current value to whatever is passed in (or 1 by default)" do
+      Sequence.new.current_value.should == 1
+      Sequence.new(500).current_value.should == 500
+    end
+  end
+  
+  describe "next" do
+    it "should return the next value in the sequence, then increment the current value" do
+      s = Sequence.new
+      s.next.should == 1
+      s.current_value.should == 2
+      s.next.should == 2
+      s.current_value.should == 3
+      
+      s = Sequence.new(500)
+      s.next.should == 500
+      s.current_value.should == 501
+      s.next.should == 501
+      s.current_value.should == 502
+    end
+  end
+end

data/spec/lib_specs/string_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe String do 
+  describe "plural?" do
+    it "should report plural symbols as plural" do
+      'apples'.plural?.should == true
+      'apple'.plural?.should == false
+    end
+  end
+  
+  describe "singular?" do
+    it "should report singular items as singular" do
+      'apples'.singular?.should == false
+      'apple'.singular?.should == true
+    end
+  end
+  
+  describe "indent" do
+    it "should default the indentional level to 2 spaces" do
+      'apples'.indent.should == "  apples"
+    end
+    
+    it "should accept an indentional level" do
+      'apples'.indent(4).should == "    apples"
+    end
+    
+    it "should indent each line of the string" do
+      "apples\noranges".indent(2).should == "  apples\n  oranges"
+    end
+  end
+end

data/spec/lib_specs/symbol_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Symbol do 
+  describe "plural?" do
+    it "should report plural symbols as plural" do
+      :apples.plural?.should == true
+      :apple.plural?.should == false
+    end
+  end
+  
+  describe "singular?" do
+    it "should report singular items as singular" do
+      :apples.singular?.should == false
+      :apple.singular?.should == true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,11 +1,8 @@
-$LOAD_PATH << './lib'
-# require 'rubygems'
-# gem 'activeresource'
-# gem 'rspec'
+$LOAD_PATH.unshift './lib'
 require 'rubygems'
 gem 'activeresource'
 gem 'rspec'
 gem 'cucumber'
 require 'cucumber'
-require 'activeresource'
+require 'active_resource'
 require 'dupe'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dupe
 version: !ruby/object:Gem::Version 
-  version: 0.3.7
+  version: 0.4.0
 platform: ruby
 authors: 
 - Matt Parker
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-28 00:00:00 -05:00
+date: 2009-12-30 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -36,15 +36,23 @@ extra_rdoc_files:
 files: 
 - README.rdoc
 - lib/dupe.rb
-- lib/dupe/active_resource.rb
-- lib/dupe/attribute.rb
-- lib/dupe/configuration.rb
+- lib/dupe/active_resource_extensions.rb
+- lib/dupe/attribute_template.rb
 - lib/dupe/cucumber_hooks.rb
+- lib/dupe/custom_mocks.rb
+- lib/dupe/database.rb
 - lib/dupe/dupe.rb
-- lib/dupe/mock_service_response.rb
+- lib/dupe/log.rb
+- lib/dupe/mock.rb
+- lib/dupe/model.rb
+- lib/dupe/network.rb
 - lib/dupe/record.rb
+- lib/dupe/rest_validation.rb
+- lib/dupe/schema.rb
 - lib/dupe/sequence.rb
+- lib/dupe/singular_plural_detection.rb
 - lib/dupe/string.rb
+- lib/dupe/symbol.rb
 - rails_generators/dupe/dupe_generator.rb
 - rails_generators/dupe/templates/custom_mocks.rb
 - rails_generators/dupe/templates/dupe_setup.rb
@@ -77,6 +85,20 @@ signing_key:
 specification_version: 3
 summary: A tool that helps you mock services while cuking.
 test_files: 
-- spec/lib_specs/dupe_record_spec.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/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