lookout-rack-test 1.0.0

data/lib/lookout/rack/test.rb

@@ -0,0 +1,8 @@
+require 'lookout/rack/test/version'
+
+module Lookout
+  module Rack
+    module Test
+    end
+  end
+end

data/lib/lookout/rack/test/cucumber.rb

@@ -0,0 +1,32 @@
+require 'rack/test'
+require 'cucumber'
+require 'liquid'
+
+require 'lookout/rack/test/cucumber/transforms'
+require 'lookout/rack/test/cucumber/general_steps'
+require 'lookout/rack/test/cucumber/before'
+
+require 'lookout/rack/test/cucumber/server' if $application_class
+
+module Lookout::Rack::Test
+  module Cucumber
+    def render_string(buffer, opts={})
+      ::Liquid::Template.parse(buffer).render(template_vars.merge(opts))
+    end
+
+    def template_vars
+      @template_vars ||= {}
+    end
+
+    def current_locale
+      I18n.locale = ENV['CUCUMBER_LOCALE'] || 'en'
+    end
+
+    def app
+      @app ||= $application_class.new if $application_class
+    end
+  end
+end
+
+World(Rack::Test::Methods)
+World(Lookout::Rack::Test::Cucumber)

data/lib/lookout/rack/test/cucumber/before.rb

@@ -0,0 +1,5 @@
+require 'timecop'
+
+Before('@timefreeze') do
+  Timecop.freeze
+end

data/lib/lookout/rack/test/cucumber/general_steps.rb

@@ -0,0 +1,42 @@
+When /^I (GET|PUT|POST|DELETE)( to)? "(.*?)"$/ do |verb, unused, url_path|
+  verb = verb.downcase.to_sym
+  send(verb, render_string(url_path))
+end
+
+When /^I (GET|POST|PUT)( to)? "([^"]*)" with:$/ do |verb, unused, url, params|
+  options = {}
+
+  params.hashes.each do |row|
+    options[row[:Name]] = render_string(row[:Value])
+  end
+
+  verb = verb.downcase.to_sym
+  send(verb, render_string(url), options)
+end
+
+When /^I (DELETE|POST) to "(.*?)" with the JSON:$/ do |verb, url, body|
+  verb = verb.downcase.to_sym
+  send(verb, render_string(url), render_string(body))
+end
+
+Then /^the response (should be|is) (\d+)$/ do |verb, code|
+  expect(last_response.status).to eq(code), "expected #{code} got #{last_response.status} \n\n #{last_response.body}
+"
+end
+
+Then /^I should be redirected to "([^"]+)"$/ do |path|
+  expect(last_response.location).to end_with path
+end
+
+Then /^I should receive the JSON:$/ do |json|
+  template_vars['timestamp'] = Time.now.utc.iso8601
+  expected = JSON.parse(render_string(json))
+
+  begin
+    received = JSON.parse(last_response.body)
+  rescue JSON::ParserError => e
+    raise "Unexpected response: #{last_response.body}\n#{e}"
+  end
+
+  expect(received).to eql(expected)
+end                                                        

data/lib/lookout/rack/test/cucumber/server.rb

@@ -0,0 +1,11 @@
+require 'rack/test'
+
+module Lookout::Rack::Test::Cucumber
+  module Server
+    def app
+      @app ||= $application_class.new if $application_class
+    end
+  end
+end
+
+World(Lookout::Rack::Test::Cucumber)

data/lib/lookout/rack/test/cucumber/transforms.rb

@@ -0,0 +1,3 @@
+Transform /^(-?\d+)$/ do |number|
+  number.to_i
+end

data/lib/lookout/rack/test/load_factories.rb

@@ -0,0 +1,5 @@
+unless $factories_loaded
+  require 'factory_girl'
+  ::FactoryGirl.find_definitions
+  $factories_loaded = true
+end

data/lib/lookout/rack/test/rake.rb

@@ -0,0 +1,16 @@
+module Lookout::Rack::Test
+  module Rake
+  end
+end
+
+# Load the rake tasks
+Dir[File.expand_path(File.dirname(__FILE__) + '/rake/*.rake')].each do |f|
+  begin
+    load f
+  rescue LoadError => ex
+    puts "Failed to load #{f}"
+    puts ex
+    puts ex.backtrace
+    exit 1
+  end
+end

data/lib/lookout/rack/test/rake/cucumber.rake

@@ -0,0 +1,16 @@
+require 'cucumber/rake/task'
+require 'ci/reporter/rake/cucumber'
+
+# parallel_tests is somewhat pointless/nonfunctional on JRuby
+unless RUBY_VERSION == 'java'
+  require 'parallel_tests/tasks'
+end
+
+namespace :cucumber do
+  Cucumber::Rake::Task.new(:api) do |t|
+    t.cucumber_opts = '--profile api'
+  end
+end
+
+Cucumber::Rake::Task.new(:cucumber) do |t|
+end

data/lib/lookout/rack/test/rake/rspec.rake

@@ -0,0 +1,21 @@
+require 'rspec/core/rake_task'
+require 'ci/reporter/rake/rspec'
+
+RSpec::Core::RakeTask.new(:spec) do |r|
+end
+
+
+namespace :spec do
+  RSpec::Core::RakeTask.new(:slow) do |r|
+    r.rspec_opts = '-t speed:slow'
+  end
+
+  RSpec::Core::RakeTask.new(:fast) do |r|
+    r.rspec_opts = '-t ~speed:slow'
+  end
+
+  RSpec::Core::RakeTask.new(:routes) do |r|
+    r.rspec_opts = '-t type:route'
+  end
+end
+

data/lib/lookout/rack/test/rspec.rb

@@ -0,0 +1,52 @@
+require 'rspec'
+require 'rack/test'
+require 'timecop'
+
+require 'lookout/rack/test/rspec/email_helpers'
+require 'lookout/rack/test/rspec/fake_request'
+require 'lookout/rack/test/rspec/model_examples'
+
+module Lookout
+  module Rack
+    module Test
+      module RSpec
+        # Takes one argument, the Models class (or module) that has a .setup and
+        # .unsetup method
+        def setup_models(models)
+          ::RSpec.configure do |c|
+            c.around(:each, :speed => :slow) do |example|
+              models.setup
+              example.run
+              models.unsetup
+            end
+      
+            c.before(:all, :speed => :slow) do
+              require 'lookout/rack/test/load_factories'
+            end
+          end
+        end
+  
+        # Takes one argument, the application (e.g., SinatraApplication)
+        def setup_routes(application)
+          ::RSpec.configure do |c|
+            c.include(::Rack::Test::Methods, :type => :route)
+  
+            require 'lookout/rack/test/rspec/route_helper'
+            $application_class = application
+            c.include(::RouteHelper, :type => :route)
+          end
+        end
+  
+        def configure_rspec
+          ::RSpec.configure do |c|
+            c.around(:each, :timefreeze => true) do |example|
+              ::Timecop.freeze do
+                example.run
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lookout/rack/test/rspec/email_helpers.rb

@@ -0,0 +1,32 @@
+require 'rspec'
+require 'set'
+require 'mercury-messages'
+
+module Lookout::Rack::Test::RSpec
+  module Emails
+    def expect_emails(expected_email_names)
+      email_names = []
+      Mercury::Messages::SendImmediateBatchEmail.stub(:new) do |mail_hash|
+        email_names << mail_hash[:email_name]
+      end
+
+      yield 
+
+      expect(Set.new(email_names)).to eql Set.new(expected_email_names)
+    end
+    
+    def expect_email_attributes(expected_attributes)
+      attributes = []
+      Mercury::Messages::SendImmediateBatchEmail.stub(:new) do |mail_hash|
+        # Get all the keys (attributes) for each of this Message's pieces
+        attributes += mail_hash[:pieces].map{|h| h[:attributes]}.map(&:keys)
+      end
+
+      yield
+
+      attributes.flatten!
+
+      expect(Set.new(attributes)).to eql Set.new(expected_attributes)
+    end
+  end
+end

data/lib/lookout/rack/test/rspec/fake_request.rb

@@ -0,0 +1,20 @@
+require 'rspec'
+
+module Lookout::Rack::Test::RSpec
+  class FakeRequest
+    attr_accessor :session, :env, :request
+    
+    def initialize
+      @session = {}
+      @env = {}
+      @request = Object.new
+      @request.stub(:path_info).and_return('')
+    end
+  
+    def redirect(path, params={}); end # So we can catch calls to the redirect method
+  
+    def halt(status, error_string); end
+  
+    def to(url); url; end
+  end
+end

data/lib/lookout/rack/test/rspec/model_examples.rb

@@ -0,0 +1,12 @@
+require 'rspec'
+
+module Lookout::Rack::Test::RSpec
+  module Models
+    shared_examples 'a timestamped model' do
+      it { should respond_to :id }
+      it { should respond_to :created_at }
+      it { should respond_to :updated_at }
+      it { should respond_to :deleted_at }
+    end
+  end
+end

data/lib/lookout/rack/test/rspec/route_helper.rb

@@ -0,0 +1,7 @@
+module Lookout::Rack::Test::RSpec
+    module RouteHelper
+      def app
+        @app ||= $application_class.new if $application_class
+      end
+    end
+end

data/lib/lookout/rack/test/version.rb

@@ -0,0 +1,7 @@
+module Lookout
+  module Rack
+    module Test
+      VERSION = "1.0.0"
+    end
+  end
+end

data/lookout-rack-test.gemspec

@@ -0,0 +1,44 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lookout/rack/test/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lookout-rack-test"
+  spec.version       = Lookout::Rack::Test::VERSION
+  spec.authors       = ["Ian Smith"]
+  spec.email         = ["ian.smith@lookout.com"]
+  spec.description   = %q{RSpec and Cucumber helpers}
+  spec.summary       = %q{}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "sinatra"
+
+  # Required for {{token}} substitutions in Cucumber API scenarios
+  spec.add_dependency 'liquid'
+  spec.add_dependency 'rspec', '~> 2.12'
+  spec.add_dependency 'ci_reporter'
+  spec.add_dependency 'nokogiri'
+  spec.add_dependency 'rack-test'
+  # For freezing time inside of tests
+  spec.add_dependency 'timecop'
+  # Used to assist with scaffolded data and generating random data
+  spec.add_dependency 'factory_girl'
+  spec.add_dependency 'cucumber'
+
+  spec.add_dependency 'capybara', '~> 2.x'
+  spec.add_dependency 'selenium-webdriver', '<= 2.35.1'
+  spec.add_dependency 'sauce-connect'
+  spec.add_dependency 'sauce', '~> 3.0'
+  spec.add_dependency 'sauce-cucumber', '~> 3.0'
+
+  spec.add_dependency 'mercury-messages'
+end

data/spec/email_helpers_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+require 'lookout/rack/test/rspec/email_helpers'
+include Lookout::Rack::Test::RSpec::Emails
+
+describe 'expect_emails' do
+  let(:expected_email_name) { 'foo' }
+  let(:unexpected_email_name) { 'bar' }
+
+  it 'If I create a Mercury::Message with the expected email_name, it should pass' do
+    expect do
+      expect_emails([expected_email_name]) do
+        Mercury::Messages::SendImmediateBatchEmail.new(:email_name => expected_email_name)
+      end
+    end.not_to raise_error
+  end
+
+  it 'If I create a Mercury::Message with the expected email_name, plus some other email(s), it should fail' do
+    expect do
+      expect_emails([expected_email_name]) do
+        Mercury::Messages::SendImmediateBatchEmail.new(:email_name => expected_email_name)
+        Mercury::Messages::SendImmediateBatchEmail.new(:email_name => unexpected_email_name)
+      end
+    end.to raise_error(ExpectationNotMetError)
+  end
+
+  it 'If I create a Mercury::Message with an unexpected email_name, it should fail' do
+    expect do
+      expect_emails([expected_email_name]) do
+        Mercury::Messages::SendImmediateBatchEmail.new(:email_name => unexpected_email_name)
+      end
+    end.to raise_error(ExpectationNotMetError)
+  end
+
+  it 'If I do not create any Mercury::Message, it should fail' do
+    expect do
+      expect_emails([expected_email_name]) do
+      end
+    end.to raise_error(ExpectationNotMetError)
+  end
+end
+
+class Array
+  # Create a hash with a key for each element in the array
+  def to_hash
+    hash = {}
+    self.each {|elt| hash[elt] = nil}
+
+    return hash
+  end
+end
+
+def expect_email_attributes_helper(expected_attrs, actual_attrs)
+  expect_email_attributes(expected_attrs) do
+    Mercury::Messages::SendImmediateBatchEmail.new(:email_name => '',
+                                                   :pieces => [{:attributes => actual_attrs.to_hash}])
+  end
+end
+
+describe 'expect_email_attributes' do
+  let(:expected_email_attributes) { ['foo', 'bar'] }
+  let(:unexpected_email_attributes) { ['baz', 'quux'] }
+
+  context 'if I create a Mercury::Message with all of - and only - the expected attributes' do
+    let(:actual_attrs) { expected_email_attributes.to_hash }
+
+    it 'should pass' do
+      expect { expect_email_attributes_helper(expected_email_attributes, actual_attrs) }.not_to raise_error
+    end
+  end
+
+  context 'if I create a Mercury::Message without all of the expected attributes' do
+    let(:actual_attrs) { [expected_email_attributes.first].to_hash }
+
+    it 'should fail' do
+      expect { expect_email_attributes_helper(expected_email_attributes, actual_attrs) }.to raise_error(ExpectationNotMetError)
+    end
+  end
+
+  context 'if I create a Mercury::Message with all of the expected attributes, plus some others' do
+    let(:actual_attrs) { [expected_email_attributes + unexpected_email_attributes].to_hash }
+
+    it 'should fail' do
+      expect { expect_email_attributes_helper(expected_email_attributes, actual_attrs) }.to raise_error(ExpectationNotMetError)
+    end
+  end
+
+  context 'if I create a Mercury::Message with unexpected attributes' do
+    let(:actual_attrs) { unexpected_email_attributes.to_hash }
+
+    it 'should fail' do
+      expect { expect_email_attributes_helper(expected_email_attributes, actual_attrs) }.to raise_error(ExpectationNotMetError)
+    end
+  end
+
+  context 'if I do not create a Mercury::Message' do
+    it 'it should fail' do
+      expect do
+        expect_email_attributes(expected_email_attributes) do
+        end
+      end.to raise_error(ExpectationNotMetError)
+    end
+  end
+end