rack-radar 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 23f9bc19a648ac577edf7b2f24c3e93ce31abb40
+  data.tar.gz: 5c2be6ea839fdfd69203e5bbac586f60b0ab5d1d
+SHA512:
+  metadata.gz: 1addf480f19db25a66c20f7e9856bc943fccb79916d5eb0b29e3ffaf05590702fdc5b44dd792b3f4ca32333010306713a1f2a8deb653b8d9198637ddb8130771
+  data.tar.gz: fa05dc0ec99d8cb6a506b8f0655bd08d91865aefaf74048fb462bd2fcc0730a780464195d7b4bcaadb2a856e21395207f72ee6ddfc9a7e729b16caa10d2224f3

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Slee Woo <mail@sleewoo.com>
+
+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,283 @@
+
+## Rack::Radar
+
+**A simple API for testing Rack applications via Rack::MockRequest**<br>
+*inspired by [rack-test](https://github.com/brynary/rack-test)*
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rack-radar'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install rack-radar
+```
+
+then load it using `require 'rack-radar'`
+
+
+## Use
+
+Simply `include Rack::Radar` in your tests.
+
+## App
+
+Call `app RackApp` inside testing suite to set app to be tested.
+
+**Minitest Example:**
+
+```ruby
+require 'rack-radar'
+
+class MyTests < MiniTest::Unit::TestCase
+
+  include Rack::Radar
+
+  def setup
+    app MyRackApp
+  end
+
+  def test
+    get '/url'
+    assert_equal last_response.status, 200
+  end
+end
+```
+
+Multiple apps can be tested within same suite.<br/>
+Each app will run own session.
+
+**Minitest Example:**
+
+```ruby
+require 'rack-radar'
+
+class MyTests < MiniTest::Unit::TestCase
+
+  include Rack::Radar
+
+  def setup
+    app MyRackApp
+  end
+
+  def test
+    # querying default app
+    get '/url'
+    assert_equal last_response.status, 200
+
+    # testing ForumApp
+    app ForumApp
+    get '/posts'
+    assert_equal last_response.status, 200
+
+    # back to default app
+    app MyRackApp
+    get '/url'
+    assert_equal last_response.status, 200
+  end
+end
+```
+
+
+## Resetting App
+
+Sometimes you need to start over with a new app in pristine state, i.e. no cookies, no headers etc.
+
+To achieve this, simply call `reset_app!` (or `reset_browser!`).
+
+## Requests
+
+Use one of `get`, `post`, `put`, `patch`, `delete`, `options`, `head`
+to make requests via Rack::Radar
+
+To make a secure request, add `s_` prefix:
+
+```ruby
+s_get  '/path'
+s_post '/path'
+# etc.
+```
+
+To make a request via XHR, aka Ajax, add `_x` suffix:
+
+```ruby
+get_x  '/path'
+post_x '/path'
+# etc.
+```
+
+To make a secure request via XHR, add both `s_` and `_x`:
+
+```ruby
+s_get_x  '/path'
+s_post_x '/path'
+# etc.
+```
+
+In terms of arguments, making HTTP requests via Rack::Radar is identical to calling regular Ruby methods.<br/>
+That's it, you do not need to join parameters into a string.<br/>
+Just pass them as usual arguments:
+
+```ruby
+post '/news', :create, :title => rand
+post '/news', :update, id, :title => rand
+get  '/news', :delete, id
+```
+
+## Map
+
+Previous example works just fine, however it is redundant and inconsistent.<br/>
+Just imagine that tested app changed its base URL from /news to /headlines.
+
+The solution is simple.<br/>
+Use `map` to define a base URL that will be prepended to each request,<br/>
+except ones starting with a slash or a protocol(http://, https:// etc.) of course.
+
+```ruby
+app MyRackApp
+map '/news'
+
+post :create, :title => rand
+post :update, id, :title => rand
+get  :delete, id
+```
+
+**Note:** requests starting with a slash or protocol(http://, https:// etc.)
+wont use base URL defined by `map`.<br/>
+
+**Note:** when you switching tested app, make sure you also change the map.
+
+To disable mapping, simply call `map nil`
+
+## Cookies
+
+**Set cookies:**
+
+```ruby
+cookies['name'] = 'value'
+```
+
+**Read cookies:**
+
+```ruby
+cookie = cookies['name']
+```
+
+**Delete a cookie:**
+
+```ruby
+cookies.delete 'name'
+```
+
+
+**Clear all cookies:**
+
+```ruby
+cookies.clear
+```
+
+Each app uses its own cookies jar.
+
+## Headers
+
+Rack::Radar allow to set headers that will be sent to app on all consequent requests.
+
+**Set headers:**
+
+```ruby
+header['User-Agent']   = 'Rack::Radar'
+header['Content-Type'] = 'text/plain'
+header['rack.input']   = 'someString'
+# etc.
+```
+
+**Read headers:**
+
+```ruby
+header = headers['User-Agent']
+# etc.
+```
+
+**Delete a header:**
+
+```ruby
+headers.delete 'User-Agent'
+```
+
+**Clear all headers:**
+
+```ruby
+headers.clear
+```
+
+Each app uses its own headers.
+
+## Authorization
+
+**Basic Auth:**
+
+```ruby
+authorize 'user', 'pass'
+```
+
+**Reset earlier set Basic authorization header:**
+
+```ruby
+reset_basic_auth!
+```
+
+**Digest Auth:**
+
+```ruby
+digest_authorize 'user', 'pass'
+```
+
+**Reset earlier set Digest authorization header:**
+
+```ruby
+reset_digest_auth!
+```
+
+**Reset ANY earlier set authorization header:**
+
+```ruby
+reset_auth!
+```
+
+## Follow Redirects
+
+By default, Rack::Radar wont follow redirects.
+
+If last response is a redirect and you want Rack::Radar to follow it, use `follow_redirect!`
+
+
+## Contributors
+
+Want to contribute? Great! Contributors highly wanted and welcome!
+
+1. Fork it
+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
+
+
+## License
+
+Copyright &copy; 2014 Slee Woo &lt;mail@sleewoo.com&gt;
+
+Distributed under the **[MIT License](https://github.com/sleewoo/rack-radar/blob/master/LICENSE)**
+
+

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rake'
+require 'bundler/gem_helper'
+require 'minispec'
+
+Bundler::GemHelper.install_tasks
+
+desc 'Run all tests'
+task :test do
+  require './test/test_setup'
+
+  Minispec.run
+end
+
+task default: :test

data/lib/rack-radar.rb

@@ -0,0 +1 @@
+require 'rack/radar'

data/lib/rack/radar.rb

@@ -0,0 +1,127 @@
+require 'uri'
+require 'forwardable'
+require 'rack'
+
+module Rack
+  module Radar
+    extend Forwardable
+
+    RACK_RADAR__REQUEST_METHODS = %w[
+      GET
+      POST
+      PUT
+      PATCH
+      DELETE
+      OPTIONS
+      HEAD
+      TRACE
+      LINK
+      UNLINK
+    ].freeze
+
+    %w[
+      header headers cookies last_request last_response
+      auth authorize basic_authorize digest_auth digest_authorize token_auth token_authorize
+      reset_auth! reset_basic_auth! reset_digest_auth! reset_token_auth!
+    ].each do |m|
+      def_delegator :__r__session, m
+    end
+
+    RACK_RADAR__DEFAULT_HOST = 'rack.radar'.freeze
+    RACK_RADAR__DEFAULT_ENV = {
+      'REMOTE_ADDR' => '127.0.0.1',
+      'HTTP_HOST' => RACK_RADAR__DEFAULT_HOST
+    }.freeze
+    RACK_RADAR__XHR_KEY = 'HTTP_X_REQUESTED_WITH'.freeze
+    RACK_RADAR__XHR_VAL = 'XMLHttpRequest'.freeze
+
+    # switch session
+    #
+    # Rack::Radar using app based sessions, that's it, creates sessions based on app __id__.
+    # you can test various apps by using `app RackApp` to switch between them.
+    #
+    def app app = nil
+      if block_given?
+        @__r__app = yield
+      elsif app
+        @__r__app = app
+      end
+      @__r__app
+    end
+
+    def map *args
+      @__r__base_url = args[0] if args.size > 0
+      @__r__base_url
+    end
+
+    def env
+      @__r__env ||= {}
+    end
+
+    def params
+      @__r__params ||= {}
+    end
+
+    def session
+      env["rack.session"] ||= {}
+    end
+
+    # reset session for current app.
+    # everything will be reset - cookies, headers, authorizations etc.
+    def reset_app!
+      __r__session :reset
+    end
+
+    alias reset_browser! reset_app!
+
+    RACK_RADAR__REQUEST_METHODS.each do |request_method|
+      define_method request_method.downcase do |*args|
+        request(:http, request_method, *args)
+      end
+      # secure
+      define_method 's_%s' % request_method.downcase do |*args|
+        request(:https, request_method, *args)
+      end
+      # xhr
+      define_method '%s_x' % request_method.downcase do |*args|
+        __r__with_xhr { request(:http, request_method, *args) }
+      end
+      # secure xhr
+      define_method 's_%s_x' % request_method.downcase do |*args|
+        __r__with_xhr { request(:https, request_method, *args) }
+      end
+    end
+
+    def request scheme, request_method, *args
+      rest, path = args.partition {|a| a.is_a?(Hash)}
+      params = self.params.merge(rest[0] || {})
+      env = self.env.merge(rest[1] || {})
+      __r__session.invoke_request(scheme, request_method, @__r__base_url, path, params, env)
+    end
+
+    def follow_redirect!
+      last_response.redirect? || raise(RuntimeError, 'Last response is not an redirect!')
+      scheme = last_request.env['HTTPS'] == 'on' ? 'https' : 'http'
+      request(scheme, 'GET', [last_response['Location']], {}, {
+        'HTTP_REFERER' => last_request.url,
+        'rack.session' => last_request.env['rack.session'],
+        'rack.session.options' => last_request.env['rack.session.options']
+      })
+    end
+
+    def __r__session reset = false
+      (@__r__session ||= {})[app.__id__]   = RackRadarSession.new(app) if reset
+      (@__r__session ||= {})[app.__id__] ||= RackRadarSession.new(app)
+    end
+
+    def __r__with_xhr
+      env_xhr = env.has_key?(RACK_RADAR__XHR_KEY) && env[RACK_RADAR__XHR_KEY]
+      env[RACK_RADAR__XHR_KEY] = RACK_RADAR__XHR_VAL unless env_xhr == RACK_RADAR__XHR_VAL
+      yield
+      env[RACK_RADAR__XHR_KEY] = env_xhr if env_xhr
+    end
+  end
+end
+
+require 'rack/radar/cookies'
+require 'rack/radar/session'