replicant 0.0.3

data/History.txt

@@ -0,0 +1,8 @@
+0.0.3 ( GET Parameter Support )
+- added support for GET parameters in URLs
+
+0.0.2 ( Bug fixes )
+- fixed intermittently hanging Thin server
+
+0.0.1 ( First gem release )
+- added gemspec, namespacing, etc

data/Manifest.txt

@@ -0,0 +1,12 @@
+History.txt
+Manifest.txt
+README
+lib/replicant
+lib/replicant/matchers.rb
+lib/replicant/response.rb
+lib/replicant/server.rb
+lib/replicant/site.rb
+lib/replicant/version.rb
+lib/replicant.rb
+spec
+spec/replicant_spec.rb

data/README

@@ -0,0 +1,42 @@
+Replicant is a Rack-based http-endpoint Gem I use in tests along with
+automation frameworks such as Watir, Selenium, or any framework which
+does not rely on Net:HTTP, and therefore cannot be mock'd using normal
+methods. It acts as a real http endpoint that can assert specific
+requests occurred with the expected post data. It's not close to being
+"done", but go ahead and take a look anyway.
+
+
+Sample Usage:
+
+require 'replicant'
+
+before do
+  @mock_website = Replicant.new
+  @mock_website.response( :login_page, "/login",
+                        %q{ <form name='login' action='/session' method='post'>
+			    <input type='text' name='username'/>
+			    <input type='password' name='password'/>
+			    <input type='submit' value='Login' /></form> } )
+
+  @mock_website.response( :session_page, "/session", "" )
+
+  @mock_website.start
+end
+
+after do
+  @mock_website.stop
+end
+
+context "when logging in" do
+  before do
+    # Your code which runs Watir/Selenium/or anything else that doesn't use Net::HTTP here
+  end
+  
+  it "accesses the login page" do
+    @mock_website.should receive_request_for( :login_page )
+  end
+
+  it "posts to the session page" do
+    @mock_website.should receive_post_for( :session_page ).with_data( "user" => "sample_user", "password" => "password" )
+  end
+end

data/lib/replicant.rb

@@ -0,0 +1,14 @@
+require 'rack'
+
+require 'replicant/site'
+require 'replicant/server'
+require 'replicant/response'
+require 'replicant/matchers'
+
+module Replicant
+  class << self
+    def new
+      Replicant::Site.new
+    end
+  end
+end

data/lib/replicant/matchers.rb

@@ -0,0 +1,15 @@
+Spec::Matchers.define :receive_request_for do |page|
+  match do |mock|
+    mock.requested?( page ) == true
+  end
+end
+
+Spec::Matchers.define :receive_post_for do |page|
+  chain :with_data do |post_data|
+    @post_data = post_data
+  end
+
+  match do |mock|
+    mock.requested_via_post?( page, @post_data ) == true
+  end
+end

data/lib/replicant/response.rb

@@ -0,0 +1,39 @@
+module Replicant
+  class Response
+    attr_reader :name, :method, :path
+
+    def initialize( name, method, path, content )
+      @name = name
+      @method = method
+      @path = path
+      @content = content
+
+      @requests = [ ]
+    end
+
+    def content( post = { } )
+      mark_as_requested( post )
+      @content
+    end
+
+    def requested?( times = 1 )
+      @requests.length == times
+    end
+
+    def requested_via_post?( post_data = { }, times = 1 )
+      @requests.all? { |request| request[ :post ] == post_data } && requested?( times )
+    end
+
+    def to_s
+      "#{@name} ( #{@path} )\n" +
+      "\tAccessed: #{@requests.length} times\n" +
+      @requests.collect { |request| "\t\t#{request[ :timestamp ]}\n\t\t#{request[ :post ]}\n\n" }.join( "\n" )
+    end
+
+    private
+
+    def mark_as_requested( post )
+      @requests << { :timestamp => Time.now, :post => post }
+    end
+  end
+end

data/lib/replicant/server.rb

@@ -0,0 +1,20 @@
+module Replicant
+  class Server
+    def self.start( mock, port = 9000 )
+      @server, @port = nil, port
+
+      @thread = Thread.new do
+        Rack::Handler::Thin.run( mock, :Port => @port ) do |server|
+          @server = server
+        end
+      end
+      
+      Thread.pass until @server && @server.running?
+    end
+
+    def self.stop
+      @server.stop!
+      @thread.terminate
+    end
+  end
+end

data/lib/replicant/site.rb

@@ -0,0 +1,78 @@
+module Replicant
+  class Site
+    def initialize
+      @responses = [ ]
+    end
+
+    def start
+      Replicant::Server.start self, 9000
+    end
+
+    def stop
+      Replicant::Server.stop
+    end
+
+    def response( name, path, content = "<html><body></body></html" )
+      remove_response_by_name( name ) if find_response_by_name( name )
+      @responses << Replicant::Response.new( name, :get, path, content )
+    end
+
+    def requested?( name, times = 1 )
+      find_response_by_name( name ).requested?( times )
+    end
+
+    def requested_via_post?( name, post_data = { }, times = 1 )
+      find_response_by_name( name ).requested_via_post?( post_data, times )
+    end
+
+    def call( env )
+      request = Rack::Request.new( env )
+      
+      status_code, content =
+        if response = find_response_by_path( request.env[ 'REQUEST_URI' ] )
+          [ 200, response.content( request.POST ) ]
+        else
+          [ 404, "Not Found" ]
+        end
+
+      [ status_code, { 'Content-Type' => 'text/html' }, [ content ] ]
+    end
+
+    def print_responses
+      @responses.each { |r| puts r }
+    end
+
+    private
+
+    def find_position( &block )
+      @responses.index &block
+    end
+
+    def find_position_by_name( name )
+      find_position { |response| response.name == name }
+    end
+
+    def find_position_by_path( path )
+      find_position { |response| path == response.path }
+    end
+
+    def find_response_by_path( path )
+      if position = find_position_by_path( path )
+        @responses[ position ]
+      end
+    end
+
+    def find_response_by_name( name )
+      if position = find_position_by_name( name )
+        @responses[ position ]
+      end
+    end
+
+    def remove_response_by_name( name )
+      if position = find_position_by_name( name )
+        @responses.delete_at position
+      end
+    end
+  end
+end
+  

data/lib/replicant/version.rb

@@ -0,0 +1,9 @@
+module Replicant
+  module VERSION
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 3
+    
+    STRING = [ MAJOR, MINOR, TINY ].join( '.' )
+  end
+end

data/spec/replicant_spec.rb

@@ -0,0 +1,42 @@
+require 'replicant'
+require 'spec'
+
+describe Replicant do
+  before do
+    @mock_website = Replicant.new
+  end
+
+  context "#response" do
+    before do
+      @mock_website.response :name, '/path', "<response>text</response>"
+    end
+
+    context "when no responses matching the given name exist" do
+      it "registers the response given" do
+        @mock_website.instance_variable_get( :@responses ).should have( 1 ).response
+
+        response = @mock_website.instance_variable_get( :@responses ).first
+
+        response.name.should == :name
+        response.path.should == '/path'
+        response.content.should == "<response>text</response>"
+      end
+    end
+
+    context "when responses matching the given name already exist" do
+      before do
+        @mock_website.response :name, '/new-path', "<response>new text</response>"
+      end
+
+      it "registers the response given" do
+        @mock_website.instance_variable_get( :@responses ).should have( 1 ).response
+
+        response = @mock_website.instance_variable_get( :@responses ).first
+
+        response.name.should == :name
+        response.path.should == '/new-path'
+        response.content.should == "<response>new text</response>"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: replicant
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- James Bobowski
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-02 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 0
+        - 1
+        version: 1.0.1
+  type: :runtime
+  version_requirements: *id001
+description: Replicant is a Rack-based http-endpoint gem used to mock/assert real http calls.
+email: 
+- james.bobowski@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- History.txt
+- Manifest.txt
+- README
+- lib/replicant.rb
+- lib/replicant/matchers.rb
+- lib/replicant/response.rb
+- lib/replicant/server.rb
+- lib/replicant/site.rb
+- lib/replicant/version.rb
+- spec/replicant_spec.rb
+has_rdoc: true
+homepage: http://github.com/jamesbobowski/replicant
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: replicant
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: Replicant is a Rack-based http-endpoint gem used to mock/assert real http calls.
+test_files: []
+