cannon 0.0.2

data/spec/features/cookies_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+RSpec.describe 'Cookies', :cannon_app do
+  before(:all) do
+    cannon_app.get('/basic') do |request, response|
+      response.cookie(:simple, value: 'value')
+      response.send("cookie = #{request.cookies[:simple]}")
+    end
+
+    cannon_app.get('/cookies') do |request, response|
+      response.cookie(:remember_me, value: 'true')
+      response.cookie(:username, value: '"Luther;Martin"', expires: Time.new(2017, 10, 31, 10, 30, 05), httponly: true)
+      response.cookie(:password, value: 'by=faith')
+      response.send("username = #{request.cookies[:username]}, password = #{request.cookies[:password]}, remember_me = #{request.cookies[:remember_me]}")
+    end
+
+    cannon_app.get('/signed') do |request, response|
+      response.cookie(:secure_value, value: 'SECURE', signed: true)
+      response.send("secure value = #{request.cookies.signed[:secure_value]}")
+    end
+
+    cannon_app.listen(async: true)
+  end
+
+  it 'reads and writes cookies' do
+    get '/basic'
+    expect(response.body).to eq('cookie = ')
+
+    get '/basic'
+    expect(response.body).to eq('cookie = value')
+  end
+
+  it 'handles cookie options' do
+    get '/cookies'
+    expect(response.body).to eq('username = , password = , remember_me = ')
+
+    expect(cookies[:username].httponly).to be true
+    expect(cookies[:username].expires).to eq(Time.new(2017, 10, 31, 10, 30, 05))
+    expect(cookies[:password].expires).to be nil
+
+    get '/cookies'
+    expect(response.body).to eq('username = "Luther;Martin", password = by=faith, remember_me = true')
+  end
+
+  describe 'signed' do
+    before(:each) do
+      get '/signed'
+      expect(response.body).to eq('secure value = ')
+    end
+
+    it 'will work if the cookie is not tampered' do
+      get '/signed'
+      expect(response.body).to eq('secure value = SECURE')
+    end
+
+    it 'will clear the cookie if the cookie is tampered' do
+      cookies[:secure_value].value.gsub!('SECURE', 'SeCURE')
+      get '/signed'
+      expect(response.body).to eq('secure value = ')
+    end
+  end
+end

data/spec/features/files_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe 'Files', :cannon_app do
+  before(:all) do
+    cannon_app.config.public_path = '../fixtures/public'
+
+    cannon_app.listen(async: true)
+  end
+
+  it 'serves files' do
+    get '/background.jpg'
+    expect(response.body.size).to_not eq('')
+    expect(response.code).to be(200)
+    expect(response['Content-Type']).to eq('image/jpeg')
+    expect(response['Content-Length']).to eq('55697')
+  end
+end

data/spec/features/method_types_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+RSpec.describe 'Method types', :cannon_app do
+  before(:all) do
+    cannon_app.get('/hi') do |request, response|
+      response.send('hi')
+    end
+
+    cannon_app.get('/value') do |request, response|
+      response.send("key = #{request.params[:key]}, place = #{request.params[:place]}")
+    end
+
+    cannon_app.post('/hi') do |request, response|
+      response.send('created!', status: :created)
+    end
+
+    cannon_app.post('/submit') do |request, response|
+      response.send("name=#{request.params[:name]}, age=#{request.params[:age]}")
+    end
+
+    cannon_app.patch('/update') do |request, response|
+      response.send("updated object #{request.params[:name]}")
+    end
+
+    cannon_app.put('/modify') do |request, response|
+      response.send("modified object #{request.params[:name]}")
+    end
+
+    cannon_app.delete('/object/:id') do |request, response|
+      response.send("deleted #{request.params[:id]}")
+    end
+
+    cannon_app.head('/object/:id') do |request, response|
+      response.header('ETag', "object_#{request.params[:id]}")
+      response.send('head body should be ignored')
+    end
+
+    cannon_app.all('/any') do |request, response|
+      response.send("request method = #{request.method}")
+    end
+
+    cannon_app.listen(async: true)
+  end
+
+  it 'handles get requests' do
+    get '/hi'
+    expect(response.code).to be(200)
+    expect(response.body).to eq('hi')
+  end
+
+  it 'handles query params' do
+    get '/value', key: 'a value', place: '12 ave st'
+    expect(response.body).to eq('key = a value, place = 12 ave st')
+  end
+
+  it 'handles post requests' do
+    post '/hi'
+    expect(response.body).to eq('created!')
+    expect(response.code).to eq(201)
+  end
+
+  it 'handles post params' do
+    post('/submit', name: 'John', age: 21)
+    expect(response.body).to eq('name=John, age=21')
+  end
+
+  it 'handles put requests' do
+    put '/modify', name: 'zebra'
+    expect(response.body).to eq('modified object zebra')
+  end
+
+  it 'handles patch requests' do
+    patch '/update', name: 'lion'
+    expect(response.body).to eq('updated object lion')
+  end
+
+  it 'handles delete requests' do
+    delete '/object/34'
+    expect(response.body).to eq('deleted 34')
+  end
+
+  describe 'head requests' do
+    it 'handles head request headers' do
+      head '/object/45'
+      expect(response.headers['etag']).to eq('object_45')
+    end
+
+    it 'does not return a body' do
+      head '/object/45'
+      expect(response.body).to be_nil
+    end
+  end
+
+  it 'can be configured to handle all methods for routes' do
+    get '/any'
+    expect(response.body).to eq('request method = GET')
+
+    post '/any'
+    expect(response.body).to eq('request method = POST')
+
+    put '/any'
+    expect(response.body).to eq('request method = PUT')
+  end
+end

data/spec/features/requests_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe 'Requests', :cannon_app do
+  before(:all) do
+    cannon_app.get('/basic') do |request, response|
+      response.send('hi')
+    end.handle do |request, response|
+      response.send(' how are you?')
+    end
+
+    cannon_app.get('/bad') do |response, request|
+      bad_fail_code
+    end
+
+    cannon_app.get('/resource/:id') do |request, response|
+      response.send("id = #{request.params[:id]}")
+    end
+
+    cannon_app.get('/:type/by-grouping/:grouping') do |request, response|
+      response.send("type=#{request.params[:type]}, grouping=#{request.params[:grouping]}, sort=#{request.params[:sort]}")
+    end
+
+    cannon_app.get('/object/:id') do |request, response|
+      response.send("view #{request.params[:id]}")
+    end
+
+    cannon_app.listen(async: true)
+  end
+
+  it 'sets the Content-Type' do
+    get '/basic'
+    expect(response['Content-Type']).to eq('text/plain; charset=us-ascii')
+  end
+
+  it 'sets the Content-Length' do
+    get '/basic'
+    expect(response['Content-Length']).to eq('15')
+  end
+
+  it 'handles params in routes' do
+    get '/resource/12'
+    expect(response.body).to eq('id = 12')
+    get '/messages/by-grouping/author', sort: 'name'
+    expect(response.body).to eq('type=messages, grouping=author, sort=name')
+  end
+
+  it 'returns 404 for not found routes' do
+    get '/badroute'
+    expect(response.code).to be(404)
+  end
+
+  it 'returns 500 for errors' do
+    old_log_level = Cannon.config.log_level
+    Cannon.config.log_level = :fatal
+    get '/bad'
+    expect(response.code).to be(500)
+    Cannon.config.log_level = old_log_level
+  end
+end

data/spec/features/views_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+RSpec.describe 'Views', :cannon_app do
+  before(:all) do
+    cannon_app.config.view_path = '../fixtures/views'
+
+    cannon_app.get('/view') do |request, response|
+      response.view('test.html')
+    end
+
+    cannon_app.get('/render') do |request, response|
+      response.view('render_test.html', name: 'John Calvin')
+    end
+
+    cannon_app.listen(async: true)
+  end
+
+  describe 'rendering' do
+    it 'handles plain text' do
+      get '/view'
+      expect(response.body).to eq('Test view content')
+      expect(response.code).to be(200)
+      expect(response['Content-Type']).to eq('text/html')
+    end
+
+    it 'handles mustache templates' do
+      get '/render'
+      expect(response.body).to eq('Hello John Calvin')
+    end
+  end
+end

data/spec/fixtures/views/render_test.html

@@ -0,0 +1 @@
+Hello {{name}}

data/spec/fixtures/views/test.html

@@ -0,0 +1 @@
+Test view content

data/spec/spec_helper.rb

@@ -0,0 +1,98 @@
+require 'cannon'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+# Require support files
+Dir[Dir.getwd + '/spec/support/**/*.rb'].each { |f| require f }
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  # config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  # config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

data/spec/support/cannon_test.rb

@@ -0,0 +1,108 @@
+require 'http-cookie'
+
+class MockResponse
+  def initialize(response)
+    @response = response
+  end
+
+  def code
+    @response.code.to_i
+  end
+
+  def headers
+    @headers ||= build_headers
+  end
+
+  def method_missing(sym, *args, &block)
+    @response.send(sym, *args, &block)
+  end
+
+private
+
+  def build_headers
+    headers = {}
+    each_header { |k, v| headers[k] = v }
+    headers
+  end
+end
+
+module Cannon::Test
+  PORT = 5031
+
+  def cannon_app
+    @cannon_app ||= create_cannon_app
+  end
+
+  def get(path, params = {})
+    http_request(path, Net::HTTP::Get, query_params: params)
+  end
+
+  def post(path, params = {})
+    http_request(path, Net::HTTP::Post, post_params: params)
+  end
+
+  def put(path, params = {})
+    http_request(path, Net::HTTP::Put, post_params: params)
+  end
+
+  def patch(path, params = {})
+    http_request(path, Net::HTTP::Patch, post_params: params)
+  end
+
+  def delete(path, params = {})
+    http_request(path, Net::HTTP::Delete, post_params: params)
+  end
+
+  def head(path, params = {})
+    http_request(path, Net::HTTP::Head, query_params: params)
+  end
+
+  def response
+    @response
+  end
+
+  def cookies
+    jar.inject({}) { |cookies, cookie| cookies[cookie.name.to_sym] = cookie; cookies }
+  end
+
+  def jar
+    @jar ||= HTTP::CookieJar.new
+  end
+
+private
+
+  def http_request(path, request_class, post_params: nil, query_params: nil)
+    uri = URI("http://127.0.0.1:#{PORT}#{path}")
+    uri.query = URI.encode_www_form(query_params) unless query_params.nil?
+    req = request_class.new(uri)
+    req.set_form_data(post_params) unless post_params.nil?
+    req['Cookie'] = HTTP::Cookie.cookie_value(jar.cookies(uri)) unless jar.empty?
+
+    @response = MockResponse.new(Net::HTTP.start(uri.hostname, uri.port) do |http|
+      http.request(req)
+    end)
+
+    if @response['Set-Cookie']
+      @response.get_fields('Set-Cookie').each do |cookie|
+        jar.parse(cookie, uri)
+      end
+    end
+  end
+
+  def create_cannon_app
+    app = Cannon::App.new(binding, port: PORT, ip_address: '127.0.0.1')
+    app.config.log_level = :error
+    app.config.cookies.secret = 'test'
+    app
+  end
+end
+
+RSpec.configure do |config|
+  config.include Cannon::Test
+
+  config.append_after(:context, cannon_app: true) do
+    cannon_app.stop
+    @cannon_app = nil
+    jar.clear
+  end
+end