so_stub_very_test 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d912b883c1d926912500fa80ce5f4e460ea01dc9
+  data.tar.gz: d82a68fabdf2f56a50b878633dcd2949dab11852
+SHA512:
+  metadata.gz: ea777bbd8495e096e869297969cdcf534601e4a889b47764a3cdaa14704328b00ca28fe4fb531b6efe534b08a8349883af8cb5a6924c94abc2021fd96545c2cf
+  data.tar.gz: ba463db45f01362989a81c6186c3d18d411ad8da0238c9496371f5117f92fe094bd890615c43932980ddfc3afc4bd1f9b68cdd7bd7a22556c6b0cad1eec2f262

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in so_stub_very_test.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jonathan Clem
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,199 @@
+# SoStubVeryTest
+
+```doge
+so stub
+
+            very test
+
+much excon
+              wow
+```
+
+SoStubVeryTest provides a simpler method for stubbing Excon in your tests, because
+typing `Excon.stub({}, {})` over and over again is like taking the first train to
+Repetitive Stress Injury town.
+
+Further, it provides an easy way to set up default stubs for your test suite, so
+that you can clear out the Excon stubs that were stubbed in your individual test
+setup, but still have useful default ones around (they usually return empty arrays
+and hashes).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'so_stub_very_test'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install so_stub_very_test
+
+## Usage
+
+### HTTP Verb Stubs
+
+SoStubVeryTest is a module that you include to provide some handy methods for
+stubbing Excon requests. Here's a random smattering of examples:
+
+```ruby
+stub_get "/foo", [1,2,3]
+# Equivalent: Excon.stub({ path: /\A\/foo\Z/, method: :get }, { body: [1,2,3] })
+#                     ^ so stubbed
+
+stub_post "/foo", body: [1,2,3], status: 201
+# Equivalent: Excon.stub({ path: /\A\/foo\Z/, method: :post }, { body: [1,2,3], status: 201 })
+#                                                         ^ very protocol
+```
+
+You can use blocks for your response body:
+
+```ruby
+stub_get "/foo" do
+  {
+    body: "no meme here"
+  }
+end
+# Equivalent: Excon.stub({ path: /\A\/foo\Z/, method: :post }, { body: "no meme here" })
+```
+
+SoStubVeryTest will naïvely turn path parameters (any group of non-`/` preceded
+by a colon) into regex thingies:
+
+```ruby
+stub_get "/foo/:bar", [1,2,3]
+# Equivalent: Excon.stub({ path: /\A\/foo\/[^\/]+\Z/, method: :get }, { body: [1,2,3] })
+#                                          ^ much regular expression
+```
+
+### Namespacing
+
+You can namespace things:
+
+```ruby
+namespace "/doges" do
+  stub_get [] # no path stubs the namespace's path
+  stub_post "/wow", [1,2,3]
+
+  namespace "/very" do
+    stub_get "/much", {}
+  end
+end
+
+# Equivalent:
+#   Excon.stub({ path: /\A\/doges\Z/, method: :get }, { body: [] })
+#   Excon.stub({ path: /\A\/doges\/wow\Z/, method: :post }, { body: [1,2,3] })
+#   Excon.stub({ path: /\A\/doges\/very\/much\Z/, method: :get }, { body: {} })
+```
+
+### Default Host Setting Upping
+
+You can set a default host:
+
+```ruby
+SoStubVeryTest.default_host = "doge.example.com"
+stub_get "/foo", [1,2,3]
+# Equivalent: Excon.stub({ path: /\A\/foo\Z/, method: :get, host: "doge.example.com" }, { body: [1,2,3] })
+```
+
+### Extra Host Setting Upping
+
+```ruby
+SoStubVeryTest.register_host :doge, "doge.example.com"
+
+# Use namespaces
+doge_namespace "/w00t" do
+  stub_get "/cool", [] # the host prefix isn't necessary when in a namespace block
+end
+
+# Or don't use namespaces
+doge_stub_get "/twinkie", []
+
+# Excon.stub({ path: /\A\/w00t\/cool\Z/, method: :get, host: "doge.example.com"})
+# Excon.stub({ path: /\A\/twinkie\Z/, method: :get, host: "doge.example.com"})
+```
+
+### Providing Default Stubs
+
+You can provide default stubs that will not be cleared when calling
+`SoStubVeryTest.clear_custom_stubs` by creating them in a special `defaults`
+block:
+
+```ruby
+# Ensures that unless you manually call `Excon.stubs.clear` or override the stub,
+# GETing /woot will always be stubbed with a `[]` response.
+SoStubVeryTest.defaults do
+  namespace "/woot" do
+    stub_get []
+  end
+end
+```
+
+## Testing with SoStubVeryTest
+
+### For RSpec
+
+In your `spec_helper.rb`, you'll probably want something like this:
+
+```ruby
+require "so_stub_very_test"
+
+RSpec.configure do |config|
+  config.include SoStubVeryTest
+
+  before :all do
+    Excon.defaults[:mock] = true
+  end
+
+  after :each do
+    SoStubVeryTest.clear_custom_stubs
+  end
+end
+```
+
+Then you can spend less time writing stubs for your specs:
+
+```ruby
+before do
+  stub_get "/doge", "hi from doge"
+end
+
+it "gets the doge" do
+  # ...
+end
+```
+
+### For Minitest
+
+I don't really use Minitest much (lol i know i'm using it in this very repo),
+but you'd probs do this:
+
+```ruby
+require "so_stub_very_test"
+
+class TestDoges < Minitest::Test
+  def setup
+    Excon.defaults[:mock] = true
+  end
+
+  def teardown
+    SoStubVeryTest.clear_custom_stubs
+  end
+
+  def test_the_doge
+    stub_get "/doge", "hi from doge"
+    assert_equal "hi from doge", Excon.get({ path: "/doge" })
+  end
+end
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/so_stub_very_test/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = "test/*_test.rb"
+end

data/lib/so_stub_very_test.rb

@@ -0,0 +1,146 @@
+require "so_stub_very_test/version"
+require "excon"
+
+module SoStubVeryTest
+  extend self
+
+  class AmbiguousResponseError < StandardError; end
+  class MixedNamespacesError   < StandardError; end
+  class NoPathGivenError       < StandardError; end
+
+  def namespace(path, host = nil, &block)
+    if stub_paths.any? && stub_host != host
+      raise MixedNamespacesError
+    end
+
+    stub_paths << path
+    self.stub_host = host || default_host
+    yield
+  ensure
+    stub_paths.pop
+
+    if stub_paths.empty?
+      self.stub_host = nil
+    end
+  end
+
+  Excon::HTTP_VERBS.each do |verb|
+    define_method "stub_#{verb}" do |path, response = nil, &block|
+      validate_path_given(path)
+
+      unless path.is_a? String
+        response = path
+        path     = ""
+      end
+
+      validate_single_response(block, response)
+
+      if block
+        response = block
+      end
+
+      path = stub_path + path
+      path = replace_path_params(path)
+      path = create_path_regexp(path)
+
+      request = { method: verb, path: path }
+
+      if stub_host || default_host
+        request[:host] = stub_host || default_host
+      end
+
+      unless response.is_a?(Proc) || (response.is_a?(Hash) && response.has_key?(:body))
+        response = { body: response }
+      end
+
+      unless SoStubVeryTest.defining_default_stubs
+        SoStubVeryTest.custom_stubs << [request, response]
+      end
+
+      Excon.stub(request, response)
+    end
+  end
+
+  class << self
+    attr_accessor :default_host
+
+    def clear_custom_stubs
+      custom_stubs.each do |stub|
+        Excon.stubs.delete stub
+      end
+
+      custom_stubs.clear
+    end
+
+    def custom_stubs
+      @custom_stubs ||= []
+    end
+
+    def defining_default_stubs
+      @defining_default_stubs ||= false
+    end
+
+    def register_host(name, host)
+      define_method "#{name}_namespace" do |path, &block|
+        namespace path, host, &block
+      end
+
+      Excon::HTTP_VERBS.each do |verb|
+        define_method "#{name}_stub_#{verb}" do |path, response = nil|
+          namespace path, host do
+            send "stub_#{verb}", response
+          end
+        end
+      end
+    end
+
+    def defaults(&block)
+      @defining_default_stubs = true
+      instance_exec &block
+    ensure
+      @defining_default_stubs = false
+    end
+  end
+
+  private
+
+  def create_path_regexp(path)
+    Regexp.new '\A' + path + '\Z'
+  end
+
+  def default_host
+    SoStubVeryTest.default_host
+  end
+
+  def replace_path_params(path)
+    path.gsub /:[^\/]+/, '[^\/]+'
+  end
+
+  def stub_host=(host)
+    @stub_host = host
+  end
+
+  def stub_host
+    @stub_host
+  end
+
+  def stub_path
+    stub_paths.join
+  end
+
+  def stub_paths
+    @stub_paths ||= []
+  end
+
+  def validate_path_given(path)
+    if stub_paths.empty? && !path.is_a?(String)
+      raise NoPathGivenError
+    end
+  end
+
+  def validate_single_response(block, response)
+    if block && response
+      raise AmbiguousResponseError
+    end
+  end
+end

data/lib/so_stub_very_test/version.rb

@@ -0,0 +1,3 @@
+module SoStubVeryTest
+  VERSION = "0.0.0"
+end

data/so_stub_very_test.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'so_stub_very_test/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "so_stub_very_test"
+  spec.version       = SoStubVeryTest::VERSION
+  spec.authors       = ["Jonathan Clem"]
+  spec.email         = ["jonathan@jclem.net"]
+  spec.summary       = %q{so stub...very test...much excon...wow}
+  spec.description   = %q{build sensible default Excon stubs...and then build more of them}
+  spec.homepage      = "https://github.com/jclem/so_stub_very_test"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "excon", "~> 0.25", ">= 0.25.1"
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+end

data/test/so_stub_very_test_test.rb

@@ -0,0 +1,198 @@
+require "test_helper"
+
+class TestSoStubVeryTest < Minitest::Test
+  include SoStubVeryTest
+
+  def teardown
+    SoStubVeryTest.default_host = nil
+    SoStubVeryTest.clear_custom_stubs
+    Excon.stubs.clear
+  end
+
+  def test_can_stub_get
+    stub_get "/foo", body: [true]
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\Z/, method: :get }, body: [true]]]
+  end
+
+  def test_can_stub_post
+    stub_post "/foo", body: [true]
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\Z/, method: :post }, body: [true]]]
+  end
+
+  def test_can_stub_put
+    stub_put "/foo", body: [true]
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\Z/, method: :put }, body: [true]]]
+  end
+
+  def test_can_stub_patch
+    stub_patch "/foo", body: [true]
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\Z/, method: :patch }, body: [true]]]
+  end
+
+  def test_can_stub_delete
+    stub_delete "/foo", body: [true]
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\Z/, method: :delete }, body: [true]]]
+  end
+
+  def test_performs_param_substitution
+    stub_get "/foo/:bar", body: [true]
+    assert_equal Excon.stubs, [[{ path: Regexp.new('\A/foo/[^\/]+\Z'), method: :get }, body: [true]]]
+  end
+
+  def test_can_have_default_host
+    SoStubVeryTest.default_host = "example.com"
+    stub_get "/foo", body: [true]
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\Z/, method: :get, host: "example.com" }, body: [true]]]
+  end
+
+  def test_can_set_response_options
+    stub_get "/foo", body: [true], status: 201
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\Z/, method: :get }, body: [true], status: 201]]
+  end
+
+  def test_need_not_pass_body_param
+    stub_get "/foo", [true]
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\Z/, method: :get }, body: [true]]]
+  end
+
+  def test_can_pass_block_as_response
+    stub_get "/foo" do
+      [true]
+    end
+
+    assert_equal Excon.stubs[0][0], { path: /\A\/foo\Z/, method: :get }
+    assert_equal Excon.stubs[0][1].call, [true]
+  end
+
+  def test_raises_exception_when_given_response_and_block
+    assert_raises SoStubVeryTest::AmbiguousResponseError do
+      stub_get "/foo", "bar" do
+        [true]
+      end
+    end
+  end
+
+  def test_raises_exception_when_given_response_and_block_with_no_path
+    assert_raises SoStubVeryTest::AmbiguousResponseError do
+      namespace "/foo" do
+        stub_get true do
+          [true]
+        end
+      end
+    end
+  end
+
+  def test_can_use_namespaces
+    namespace "/foo" do
+      stub_get "/bar", true
+    end
+
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\/bar\Z/, method: :get }, { body: true }]]
+  end
+
+  def test_can_nest_namespaces
+    namespace "/foo" do
+      namespace "/bar" do
+        stub_get "/baz", true
+      end
+    end
+
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\/bar\/baz\Z/, method: :get }, { body: true }]]
+  end
+
+  def test_can_use_no_path_when_in_namespace
+    namespace "/foo" do
+      stub_get true
+    end
+
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\Z/, method: :get }, { body: true }]]
+  end
+
+  def test_raises_no_path_when_not_given_path_outside_of_namespace
+    assert_raises SoStubVeryTest::NoPathGivenError do
+      stub_get true
+    end
+  end
+
+  def test_clears_namespaces_each_block
+    namespace "/foo" do
+    end
+
+    namespace "/bar" do
+      stub_get true
+    end
+
+    assert_equal Excon.stubs, [[{ path: /\A\/bar\Z/, method: :get }, { body: true }]]
+  end
+
+  def test_can_define_more_namespaces
+    SoStubVeryTest.register_host :foo, "foo.example.com"
+    foo_namespace "/foo" do
+      stub_get true
+    end
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\Z/, host: "foo.example.com", method: :get }, { body: true }]]
+  end
+
+  def test_new_namespaces_come_with_http_verb_methods
+    SoStubVeryTest.register_host :foo, "foo.example.com"
+    foo_stub_get "/foo", true
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\Z/, host: "foo.example.com", method: :get }, { body: true }]]
+  end
+
+  def test_can_not_mismatch_namespaces
+    SoStubVeryTest.register_host :foo, "foo.example.com"
+
+    assert_raises SoStubVeryTest::MixedNamespacesError do
+      namespace "/foo" do
+        foo_namespace "bar" do
+        end
+      end
+    end
+  end
+
+  def test_can_not_mismatch_namespaces_and_http_verb_methods
+    SoStubVeryTest.register_host :foo, "foo.example.com"
+
+    assert_raises SoStubVeryTest::MixedNamespacesError do
+      namespace "/foo" do
+        foo_stub_get true
+      end
+    end
+  end
+
+  def test_unsets_stub_host_after_each_namespace
+    SoStubVeryTest.register_host :foo, "foo.example.com"
+
+    foo_namespace "/foo" do
+      stub_get true
+    end
+
+    stub_get "/bar", true
+
+    assert_equal Excon.stubs[0], [{ path: /\A\/bar\Z/, method: :get }, body: true]
+  end
+
+  def test_can_have_default_stubs
+    SoStubVeryTest.defaults do
+      stub_get "/bar", true
+    end
+
+    assert_equal Excon.stubs, [[{ path: /\A\/bar\Z/, method: :get }, body: true]]
+  end
+
+  def test_can_clear_stubs
+    stub_get "/bar", true
+    SoStubVeryTest.clear_custom_stubs
+    assert_empty Excon.stubs
+  end
+
+  def test_does_not_clear_default_stubs
+    SoStubVeryTest.defaults do
+      stub_get "/foo", true
+    end
+
+    stub_get "/bar", true
+    SoStubVeryTest.clear_custom_stubs
+    assert_equal Excon.stubs, [[{ path: /\A\/foo\Z/, method: :get }, body: true]]
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require "so_stub_very_test"
+require "excon"
+require "minitest/autorun"
+require "minitest/pride"
+require "minitest/unit"

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: so_stub_very_test
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Jonathan Clem
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.25'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.25.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.25'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.25.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: build sensible default Excon stubs...and then build more of them
+email:
+- jonathan@jclem.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/so_stub_very_test.rb
+- lib/so_stub_very_test/version.rb
+- so_stub_very_test.gemspec
+- test/so_stub_very_test_test.rb
+- test/test_helper.rb
+homepage: https://github.com/jclem/so_stub_very_test
+licenses:
+- MIT
+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.2.0
+signing_key: 
+specification_version: 4
+summary: so stub...very test...much excon...wow
+test_files:
+- test/so_stub_very_test_test.rb
+- test/test_helper.rb
+has_rdoc: