reevoomark-ruby-api 2.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    M2NiODc2MzQyMjljMDQxMTFlMzAxNjlkZGVhNmU1ZDFiM2EyZjM4OA==
+  data.tar.gz: !binary |-
+    MTI5YmQzOWFlZTRiNTUzMzA3YWY0YmM4N2NjYTk4MGJlODI0NTk4NQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZjE5N2IxNDJkMTAzMjE2ZWRkNDUzMTUxMDY1MWFiZTNhMjIyMWMyOTRmYTk4
+    ZTI4YTRmYjViYTFkMzA3NjM1NDNjZDNmZDA5MTFmMTQ1MWIzZThiZGQxZjg3
+    YTRiZTYyZDI1ZDEyNDIwY2JkNjIwNmRlYzQ1N2IyNTUxOTQ3MDQ=
+  data.tar.gz: !binary |-
+    ZjNhYzhhODZkN2Y5NTYwMTY4Zjc1Y2RmMTg5YmYyM2FkNzk1YTQ1OWMzZjk1
+    ZTE3OTE3MTMzYjQzMGM4MDE4ZjMzZDU3NmIzZjg2MWExYzAzNzlkOWEyMzg5
+    NWM4ODdhYzE1MDQ4ZjE1NjVmN2E2YjgxYjU5NGYwMGJlZTJjNzE=

data/lib/reevoomark.rb

@@ -0,0 +1,42 @@
+require 'fileutils'
+require 'uri'
+require 'httpclient'
+require 'digest/md5'
+
+
+# Usage:
+#
+# # Somewhere in you application config, build a client.
+# $reevoomark_client = ReevooMark.create_client(
+#   Rails.root.join("tmp/reevoo_cache"),
+#   "http://mark.reevoo.com/reevoomark/embeddable_reviews.html"
+# )
+#
+# # In your controller (assuming @entry.sku is your product SKU):
+# @reevoo_reviews = $reevoomark_client.fetch('YOUR TRKREF', @entry.sku)
+#
+# # In your view:
+# <%= @reevoo_reviews.body %>
+
+module ReevooMark
+  # Legacy API.
+  # Creates a new client every time, so considered bad for business.
+  def self.new(cache_dir, url, trkref, sku)
+    create_client(cache_dir, url).fetch(trkref, sku)
+  end
+
+  # Creates a new client.
+  def self.create_client(cache_dir, base_url, options = {})
+    cache = ReevooMark::Cache.new(cache_dir)
+    fetcher = ReevooMark::Fetcher.new(options[:timeout] || 1)
+    ReevooMark::Client.new(cache, fetcher, base_url)
+  end
+end
+
+require 'reevoomark/version'
+require 'reevoomark/document'
+require 'reevoomark/document/factory'
+require 'reevoomark/client'
+require 'reevoomark/fetcher'
+require 'reevoomark/cache'
+require 'reevoomark/cache/entry'

data/lib/reevoomark/cache.rb

@@ -0,0 +1,32 @@
+class ReevooMark::Cache
+  # Create a new cache repository, storing it's cache in the given dir.
+  def initialize(cache_dir)
+    FileUtils.mkdir_p(cache_dir) unless File.exist?(cache_dir)
+    @cache_dir = cache_dir
+  end
+
+  # Fetch the cache entry, don't worry if it's expired.
+  def fetch_expired(remote_url, options = {})
+    entry = entry_for(remote_url)
+    if entry.exists?
+      entry.revalidate_for(options[:revalidate_for])
+      entry.document
+    end
+  end
+
+  # Fetch an unexpired cached document, or store the result of the block.
+  def fetch(remote_url, &fetcher)
+    entry = entry_for(remote_url)
+    if entry.valid?
+      entry.document
+    else
+      entry.document = fetcher.call
+    end
+  end
+
+protected
+  def entry_for(remote_url)
+    digest = Digest::MD5.hexdigest(remote_url)
+    Entry.new("#{@cache_dir}/#{digest}.cache")
+  end
+end

data/lib/reevoomark/cache/entry.rb

@@ -0,0 +1,49 @@
+class ReevooMark::Cache::Entry
+  attr_reader :cache_path
+
+  def initialize(cache_path)
+    @cache_path = Pathname.new(cache_path)
+  end
+
+  def exists?
+    @cache_path.exist?
+  end
+
+  def expired?
+    document.expired?
+  end
+
+  def valid?
+    exists? and not expired?
+  end
+
+  def document
+    raise "Loading from cache, where no cache exists is bad." unless exists?
+    @document ||= YAML.load(read)
+  end
+
+  def document= doc
+    @document = nil # Flush the memoized value
+    write doc.to_yaml
+    doc
+  end
+
+  def revalidate_for(max_age)
+    if exists?
+      self.document = document.revalidated_for(max_age)
+    end
+  end
+
+protected
+  def m_time
+    cache_path.mtime if exists?
+  end
+
+  def write(data)
+    cache_path.open('w'){ |f| f.puts data }
+  end
+
+  def read
+    cache_path.read if exists?
+  end
+end

data/lib/reevoomark/client.rb

@@ -0,0 +1,29 @@
+class ReevooMark::Client
+  DEFAULT_URL = 'http://mark.reevoo.com/reevoomark/embeddable_reviews.html'
+
+  def initialize(cache, fetcher, url = DEFAULT_URL)
+    @cache, @fetcher, @url = cache, fetcher, url
+  end
+
+  def fetch(trkref, sku)
+    remote_url = url_for(trkref, sku)
+    @cache.fetch(remote_url){ remote_fetch(remote_url) }
+  end
+
+protected
+
+  def remote_fetch(remote_url)
+    document = @fetcher.fetch(remote_url)
+    if document.status_code < 500
+      document
+    else
+      @cache.fetch_expired(remote_url, :revalidate_for => 300) || document
+    end
+  end
+
+  def url_for(trkref, sku)
+    sep = (@url =~ /\?/) ? "&" : "?"
+    "#{@url}#{sep}sku=#{sku}&retailer=#{trkref}"
+  end
+
+end

data/lib/reevoomark/document.rb

@@ -0,0 +1,90 @@
+class ReevooMark::Document
+  attr_reader :time, :status_code, :age, :max_age, :counts
+
+  def self.from_response(response)
+    ReevooMark::Document::Factory.from_response(response)
+  end
+
+  def self.error
+    ReevooMark::Document::Factory.new_error_document
+  end
+
+  def initialize(time, max_age, age, status_code, body, counts)
+    @time, @max_age, @age = time, max_age, age
+    @status_code, @body = status_code, body
+    @counts = counts
+  end
+
+  def identity_values
+    [current_age(0), @content_values]
+  end
+
+  def content_values
+    [@status_code, @body, @counts]
+  end
+
+  def == other
+    identity_values == other.identity_values
+  end
+
+  def === other
+    content_values == other.content_values
+  end
+
+  def any?
+    review_count > 0
+  end
+
+  def review_count
+    @counts[:review_count]
+  end
+
+  def offer_count
+    @counts[:offer_count]
+  end
+
+  def conversation_count
+    @counts[:conversation_count]
+  end
+
+  def best_price
+    @counts[:best_price]
+  end
+
+  def is_valid?
+    status_code < 500
+  end
+
+  def body
+    if is_valid?
+      @body
+    else
+      ""
+    end
+  end
+
+  alias render body
+
+  def expired?(now = nil)
+    now ||= Time.now
+    max_age < current_age(now)
+  end
+
+  def revalidated_for(max_age)
+    ReevooMark::Document.new(
+      Time.now.to_i,
+      max_age || @max_age,
+      0,
+      @status_code,
+      @body,
+      @counts
+    )
+  end
+
+protected
+  def current_age(now = nil)
+    now ||= Time.now.to_i
+    now.to_i - (time.to_i - age.to_i)
+  end
+
+end

data/lib/reevoomark/document/factory.rb

@@ -0,0 +1,54 @@
+module ReevooMark::Document::Factory
+  class HeaderSet < Hash
+    def initialize(hash)
+      hash.each do |k,v|
+        self[k] = v
+      end
+    end
+
+    def [] k
+      super(k.downcase)
+    end
+
+    def []= k,v
+      super(k.downcase, v)
+    end
+  end
+
+  HEADER_MAPPING = {
+    :review_count => 'X-Reevoo-ReviewCount',
+    :offer_count => 'X-Reevoo-OfferCount',
+    :conversation_count => 'X-Reevoo-ConversationCount',
+    :best_price => 'X-Reevoo-BestPrice'
+  }
+
+  # Factory method for building a document from a HTTP response.
+  def self.from_response(response)
+    headers = HeaderSet.new(response.headers)
+
+    counts = HEADER_MAPPING.inject(Hash.new(0)){ |acc, (name, header)|
+      acc.merge(name => headers[header].to_i)
+    }
+
+    if cache_header = headers['Cache-Control']
+      max_age = cache_header.match("max-age=([0-9]+)")[1].to_i
+    else
+      max_age = 300
+    end
+
+    age = headers['Age'].to_i
+
+    ReevooMark::Document.new(
+      Time.now,
+      max_age,
+      age,
+      response.status_code,
+      response.body,
+      counts
+    )
+  end
+
+  def self.new_error_document
+    ReevooMark::Document.new(Time.now, 300, 0, 599, "", {})
+  end
+end

data/lib/reevoomark/fetcher.rb

@@ -0,0 +1,43 @@
+class ReevooMark::Fetcher
+  FetchError = Class.new(RuntimeError)
+
+  attr_reader :headers
+
+  def initialize(timeout)
+    @timeout = timeout
+    @http_client = HTTPClient.new
+    @http_client.connect_timeout = timeout
+    @headers = {
+      'User-Agent' => "ReevooMark Ruby Widget/#{ReevooMark::VERSION}",
+      'Referer' => "http://#{Socket::gethostname}"
+    }
+  end
+
+  def fetch(remote_url)
+    response = fetch_http(remote_url)
+    ReevooMark::Document.from_response(response)
+  rescue FetchError
+    ReevooMark::Document.error
+  end
+
+protected
+
+  def log(message)
+    if defined? Rails
+      Rails.logger.debug message
+    else
+      STDERR.puts message
+    end
+  end
+
+  def fetch_http(remote_url)
+    log "ReevooMark::Fetcher: Fetching #{remote_url}"
+    Timeout.timeout(@timeout){
+      return @http_client.get(remote_url, nil, headers)
+    }
+  rescue => e
+    raise FetchError, "#{e.class} #{e.message}"
+  end
+
+end
+

data/lib/reevoomark/version.rb

@@ -0,0 +1,3 @@
+module ReevooMark
+  VERSION="2.0.0"
+end

data/spec/acceptance/reevoomark_caching_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe "ReevooMark caching" do
+  before do
+    stub_request(:get, /.*example.*/).to_return(:body => "test")
+  end
+
+  context 'with an empty cache' do
+    it 'saves a valid fetched response to the cache file' do
+      ReevooMark.new("tmp/cache/", "http://example.com/foo", "PNY", "SKU123")
+
+      filename = Digest::MD5.hexdigest("http://example.com/foo?sku=SKU123&retailer=PNY")
+      File.open("tmp/cache/#{filename}.cache", 'r').read.should match(/test/)
+    end
+
+    it "saves a 404 response to the cache file" do
+      stub_request(:get, /.*example.*/).to_return(:body => "No content found", :status => 404)
+      ReevooMark.new("tmp/cache/", "http://example.com/foo", "PNY", "SKU123")
+
+      filename = Digest::MD5.hexdigest("http://example.com/foo?sku=SKU123&retailer=PNY")
+      File.open("tmp/cache/#{filename}.cache", 'r').read.should match(/No content found/)
+    end
+
+    it "saves a 500 response to the cache file" do
+      stub_request(:get, /.*example.*/).to_return(:body => "My face is on fire", :status => 500)
+      ReevooMark.new("tmp/cache/", "http://example.com/foo", "PNY", "SKU123")
+
+      filename = Digest::MD5.hexdigest("http://example.com/foo?sku=SKU123&retailer=PNY")
+      File.open("tmp/cache/#{filename}.cache", 'r').read.should match(/My face is on fire/)
+    end
+  end
+
+  context 'with a valid cache' do
+    before do
+      filename = Digest::MD5.hexdigest("http://example.com/foo?sku=SKU123&retailer=PNY")
+      example = ReevooMark::Document.new(
+        Time.now.to_i,
+        1,
+        0,
+        200,
+        "I'm a cache record.",
+        :review_count => 1,
+        :offer_count => 2,
+        :conversation_count => 3,
+        :best_price => 4
+      )
+
+      File.open("tmp/cache/#{filename}.cache", 'w') do |file|
+        file << example.to_yaml
+      end
+    end
+
+    subject {ReevooMark.new("tmp/cache/", "http://example.com/foo", "PNY", "SKU123")}
+
+    it "does NOT make an http request" do
+      subject
+      WebMock.should_not have_requested(:get, "http://example.com/foo?sku=SKU123&retailer=PNY")
+    end
+
+    it "returns the cached response body" do
+      subject.review_count.should == 1
+      subject.offer_count.should == 2
+      subject.conversation_count.should == 3
+      subject.best_price.should == 4
+      subject.render.should == "I'm a cache record."
+    end
+  end
+
+  context 'with an expired cache' do
+    before do
+      filename = Digest::MD5.hexdigest("http://example.com/foo?sku=SKU123&retailer=PNY")
+      example = ReevooMark::Document.new(
+        Time.now.to_i - 60*60,
+        1,
+        0,
+        200,
+        "I'm a cache record.",
+        :review_count => 1,
+        :offer_count => 2,
+        :conversation_count => 3,
+        :best_price => 4
+      )
+
+      File.open("tmp/cache/#{filename}.cache", 'w') do |file|
+        file << example.to_yaml
+      end
+    end
+
+    subject {ReevooMark.new("tmp/cache/", "http://example.com/foo", "PNY", "SKU123")}
+
+    it "makes an http request" do
+      subject
+      WebMock.should have_requested(:get, "http://example.com/foo?sku=SKU123&retailer=PNY")
+    end
+
+    context "and a functioning server" do
+      it "returns the response body" do
+        subject.render.should == "test"
+      end
+      it 'saves the fetched response to the cache file' do
+        subject
+        filename = Digest::MD5.hexdigest("http://example.com/foo?sku=SKU123&retailer=PNY")
+        File.open("tmp/cache/#{filename}.cache", 'r').read.should match(/test/)
+      end
+    end
+
+    context "and an erroring server" do
+
+      before do
+        stub_request(:get, /.*example.*/).to_return(:body => "My face is on fire", :status => 500)
+      end
+
+      it "returns the cached response body" do
+        subject.render.should == "I'm a cache record."
+      end
+
+      it 'does not save the fetched response to the cache file' do
+        subject
+        filename = Digest::MD5.hexdigest("http://example.com/foo?sku=SKU123&retailer=PNY")
+        File.open("tmp/cache/#{filename}.cache", 'r').read.should match(/I'm a cache record/)
+      end
+    end
+
+  end
+
+end

data/spec/acceptance/reevoomark_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe ReevooMark do
+
+  describe "a new ReevooMark instance" do
+    it "requires 4 arguments" do
+      lambda { ReevooMark.new }.should raise_exception ArgumentError
+    end
+
+    describe "the http request it makes" do
+      it "GETs the url with the trkref and sku" do
+        stub_request(:get, "http://example.com/foo?sku=SKU123&retailer=PNY").to_return(:body => "")
+        ReevooMark.new("tmp/cache/", "http://example.com/foo", "PNY", "SKU123")
+        WebMock.should have_requested(:get, "http://example.com/foo?sku=SKU123&retailer=PNY")
+      end
+
+      it "copes fine with urls that already have query strings" do
+        stub_request(:get, "http://example.com/foo?bar=baz&sku=SKU123&retailer=PNY").to_return(:body => "")
+        ReevooMark.new("tmp/cache/", "http://example.com/foo?bar=baz", "PNY", "SKU123")
+        WebMock.should have_requested(:get, "http://example.com/foo?bar=baz&sku=SKU123&retailer=PNY")
+      end
+
+      it "passes the correct headers in the request" do
+        stub_request(:get, /.*example.*/).to_return(:body => "")
+        expected_headers_hash = {
+          'User-Agent' => "ReevooMark Ruby Widget/#{ReevooMark::VERSION}",
+          'Referer' => "http://#{Socket::gethostname}"
+        }
+
+        ReevooMark.new("tmp/cache/", "http://example.com/foo", "PNY", "SKU123")
+        WebMock.should have_requested(:get, /.*example.*/).with(:headers => expected_headers_hash)
+      end
+    end
+  end
+
+  context "with a new ReevooMark instance" do
+    before do
+      stub_request(:get, /.*example.*/).to_return(
+        :headers => {
+          "X-Reevoo-ReviewCount" => 12,
+          "X-Reevoo-OfferCount" => 9,
+          "X-Reevoo-ConversationCount" => 165,
+          "X-Reevoo-BestPrice" => 19986
+        },
+        :body => "test"
+      )
+    end
+    subject { ReevooMark.new("tmp/cache/", "http://example.com/foo", "PNY", "SKU123") }
+
+    it "parses the body" do
+      subject.render.should == "test"
+    end
+
+    it 'parses the headers' do
+      subject.review_count.should == 12
+      subject.offer_count.should == 9
+      subject.conversation_count.should == 165
+      subject.best_price.should == 19986
+    end
+  end
+
+  context "with a ReevooMark instance that failed to load due to server error" do
+
+    before do
+      stub_request(:get, /.*example.*/).to_return(:body => "Some sort of server error", :status => 500)
+    end
+    subject { ReevooMark.new("tmp/cache/", "http://example.com/foo", "PNY", "SKU123") }
+
+    describe "#render" do
+      it "returns a blank string" do
+        subject.render.should == ""
+      end
+    end
+
+    it 'returns zero for the counts' do
+      subject.review_count.should be_zero
+      subject.offer_count.should be_zero
+      subject.conversation_count.should be_zero
+      subject.best_price.should be_zero
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'pry'
+require 'rspec'
+require 'webmock/rspec'
+require 'reevoomark'
+
+# Dir["spec/support/**/*.rb"].each { |f| require File.expand_path(f) }
+
+RSpec.configure do |config|
+  config.before do
+    FileUtils.rm Dir.glob('tmp/cache/*')
+  end
+end

data/spec/unit/cache_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe ReevooMark::Cache do
+  subject{ ReevooMark::Cache.new("tmp/cache") }
+  let(:valid_doc){
+    ReevooMark::Document.new(Time.now.to_i, 100, 0, 200, "I am a document", {})
+  }
+  let(:expired_doc){
+    ReevooMark::Document.new(Time.now.to_i - 101, 100, 0, 200, "I am a document", {})
+  }
+
+  describe "#fetch" do
+
+    it "fetches valid documents" do
+      subject.fetch("foo"){ valid_doc } # Prime cache
+      doc = subject.fetch("foo"){ raise "Was not expecting to be run" }
+      doc.should == valid_doc
+    end
+
+    it "skips expired documents" do
+      subject.fetch("foo"){ expired_doc } # Prime cache
+      doc = subject.fetch("foo"){ valid_doc }
+      doc.should == valid_doc
+      doc = subject.fetch("foo"){ raise "Don't get here" }
+      doc.should == valid_doc
+    end
+
+  end
+
+  describe "fetch_expired" do
+    it "returns even an expires document" do
+      subject.fetch("foo"){ expired_doc } # Prime cache
+      revalidated = subject.fetch_expired("foo", :revalidate_for => 30)
+      revalidated.should === expired_doc
+      revalidated.should_not be_expired
+    end
+
+    it "returns nil if nothing was found" do
+      subject.fetch_expired('bar', :revalidate_for => 30).should be_nil
+    end
+  end
+end

data/spec/unit/client_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe ReevooMark::Client do
+  let(:valid_doc){
+    ReevooMark::Document.new(Time.now.to_i, 100, 0, 200, "I am a document", {})
+  }
+  let(:invalid_doc){
+    ReevooMark::Document.new(Time.now.to_i, 100, 0, 500, "I am a ndnsment", {})
+  }
+
+  let(:cache){ double(:cache) }
+  let(:fetcher){ double(:fetcher) }
+  let(:url){ "http://example.com/foo?bar=bum" }
+  subject{
+    ReevooMark::Client.new(cache, fetcher, url)
+  }
+
+  describe "#fetch" do
+    it "fetches from the cache first" do
+      cache.should_receive(:fetch).with(
+        "http://example.com/foo?bar=bum&sku=123&retailer=TST"
+      )
+
+      subject.fetch("TST", "123")
+    end
+
+    it "uses the remote_fetcher if the cache misses" do
+      def cache.fetch(remote_url, &block)
+        yield
+      end
+
+      fetcher.should_receive(:fetch).and_return valid_doc
+      subject.fetch("TST", "123").should == valid_doc
+    end
+
+
+    it "falls back to an existing cached document if response is an error" do
+      def cache.fetch(remote_url, &block)
+        yield
+      end
+      cache.should_receive(:fetch_expired).and_return(valid_doc)
+      fetcher.should_receive(:fetch).and_return invalid_doc
+      subject.fetch("TST", "123").should == valid_doc
+    end
+
+    it "if all we have is errors, let them eat errors" do
+      def cache.fetch(remote_url, &block)
+        yield
+      end
+      cache.should_receive(:fetch_expired).and_return(invalid_doc)
+      fetcher.should_receive(:fetch).and_return invalid_doc
+      subject.fetch("TST", "123").should == invalid_doc
+    end
+  end
+
+end

data/spec/unit/document_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe ReevooMark::Document do
+  describe "#any?" do
+    it "returns true iff the review_count > 0" do
+      doc = ReevooMark::Document.new(
+        time = double(),
+        max_age = double(),
+        age = double(),
+        status_code = double(),
+        body = double(),
+        counts = {:review_count => 4}
+      )
+
+      doc.any?.should be_true
+    end
+
+    it "returns false iff the review_count <= 0" do
+      doc = ReevooMark::Document.new(
+        time = double(),
+        max_age = double(),
+        age = double(),
+        status_code = double(),
+        body = double(),
+        counts = {:review_count => 0}
+      )
+
+      doc.any?.should be_false
+    end
+  end
+
+  it "has some attributes it just parrots back" do
+    doc = ReevooMark::Document.new(
+      time = double(),
+      max_age = double(),
+      age = double(),
+      status_code = double(),
+      body = double(),
+      counts = double()
+    )
+
+    doc.time.should be time
+    doc.max_age.should be max_age
+    doc.age.should be age
+    doc.status_code.should be status_code
+    doc.counts.should be counts
+  end
+
+  describe '#body' do
+    it "returns blank if isn't valid" do
+      doc = ReevooMark::Document.new(
+        time = double(),
+        max_age = double(),
+        age = double(),
+        status_code = 500,
+        body = double(),
+        counts = double()
+      )
+
+      doc.body.should == ""
+    end
+
+    it "returns the body if it's valid" do
+      doc = ReevooMark::Document.new(
+        time = double(),
+        max_age = double(),
+        age = double(),
+        status_code = 200,
+        body = double(),
+        counts = double()
+      )
+
+      doc.body.should == body
+
+      doc = ReevooMark::Document.new(
+        time = double(),
+        max_age = double(),
+        age = double(),
+        status_code = 499,
+        body = double(),
+        counts = double()
+      )
+
+      doc.render.should == body
+    end
+
+    context "with a documnt" do
+      let(:doc){
+        ReevooMark::Document.new(
+          time = 10,
+          max_age = 10,
+          age = 5,
+          nil, nil, nil
+        )
+      }
+
+      describe '#has_expired?' do
+        it "is expired after the correct number of secconds" do
+          doc.should_not be_expired(1)
+          doc.should_not be_expired(6)
+          doc.should_not be_expired(11)
+          doc.should be_expired(16)
+        end
+      end
+
+      describe "#revalidated_for" do
+        it "creates a new document, valid for a given ammoiunt of time" do
+          doc.revalidated_for(1).should_not be_expired
+          doc.revalidated_for(-1).should be_expired
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/fetcher_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe ReevooMark::Fetcher do
+  describe "#fetch" do
+
+    it "responds with a 5xx when the server is slow" do
+      fetcher = ReevooMark::Fetcher.new(1)
+      Timeout.should_receive(:timeout).and_raise(Timeout::Error)
+      document = fetcher.fetch("http://example.com/foo")
+      document.status_code.should == 599
+    end
+
+    it "responds with a 5xx when the server is broken" do
+      fetcher = ReevooMark::Fetcher.new(1)
+      HTTPClient.any_instance.should_receive(:get).and_raise(RuntimeError)
+      document = fetcher.fetch("http://example.com/foo")
+      document.status_code.should == 599
+    end
+
+    it "responds with a document when all is fine" do
+      fetcher = ReevooMark::Fetcher.new(1)
+      stub_request(:get, /.*example.*/).to_return(:body => "", :status => 200)
+      document = fetcher.fetch("http://example.com/foo")
+      document.status_code.should == 200
+    end
+
+    it "responds with a document when there is a 404" do
+      fetcher = ReevooMark::Fetcher.new(1)
+      stub_request(:get, /.*example.*/).to_return(:body => "foo", :status => 404)
+      document = fetcher.fetch("http://example.com/foo")
+      document.status_code.should == 404
+      document.body.should == "foo"
+    end
+
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: reevoomark-ruby-api
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Reevoo Developers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Reevoo's ReevooMark & Traffic server-side ruby implementation. This API
+  is free to use but requires you to be a Reevoo customer.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/reevoomark/cache/entry.rb
+- lib/reevoomark/cache.rb
+- lib/reevoomark/client.rb
+- lib/reevoomark/document/factory.rb
+- lib/reevoomark/document.rb
+- lib/reevoomark/fetcher.rb
+- lib/reevoomark/version.rb
+- lib/reevoomark.rb
+- spec/acceptance/reevoomark_caching_spec.rb
+- spec/acceptance/reevoomark_spec.rb
+- spec/spec_helper.rb
+- spec/unit/cache_spec.rb
+- spec/unit/client_spec.rb
+- spec/unit/document_spec.rb
+- spec/unit/fetcher_spec.rb
+homepage: http://www.reevoo.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Implement ReevooMark on your ruby-based website.
+test_files: []