cardiac 0.2.0.pre2

data/spec/shared/cardiac/resource/extension_methods_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+describe Cardiac::ExtensionMethods do
+
+  let(:base_url) { 'http://localhost/prefix/segment/suffix?q=foobar' }
+  let(:base_uri) { URI(base_url) }
+  let(:resource) { Cardiac::Resource.new(base_uri) }
+  let(:void)     { lambda{||} }
+
+  subject { resource }
+
+  describe '#operation()' do
+    subject do
+      lambda{|n,b| resource.operation(n, b).send(:build_extension_module) }
+    end
+
+    it 'should define operations on an extension module' do
+      mod = subject[:foo, lambda{|| :bar }]
+      expect(mod).to be_a(Module)
+      expect(mod).to be_method_defined(:foo)
+      expect(Object.new.tap{|x| x.extend mod }.foo).to eq(:bar)
+      expect(resource).not_to respond_to(:foo)
+    end
+
+    it 'should not execute the implementation block' do
+      expect { subject[:all, lambda{|| raise 'should not happen' }] }.not_to raise_error
+    end
+
+    it 'should not be allowed to override a subresource' do
+      resource.send(:subresources_values) << [:all, void, nil]
+      expect { subject[:all, void] }.to raise_error(ArgumentError, ":all has already been defined as a subresource")
+    end
+
+    it 'must be identified by a Symbol or String' do
+      expect { subject[1, void] }.to raise_error(ArgumentError)
+      expect { subject[nil, void] }.to raise_error(ArgumentError)
+    end
+
+    it 'must be implemented by a Proc' do
+      expect { subject[1, :get] }.to raise_error(ArgumentError)
+      expect { subject[nil, 'get'] }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#extending()' do
+    it 'must be implemented by a Module' do
+      expect { resource.extending(Proc.new{}){ def foo; :bar end }.send(:build_extension_module) }.to raise_error(ArgumentError)
+      expect { resource.extending(Module.new){ def foo; :bar end }.send(:build_extension_module) }.not_to raise_error
+    end
+
+    it 'should not require an extension block' do
+      expect { resource.extending(Module.new){}.send(:build_extension_module) }.not_to raise_error
+      expect { resource.extending(Module.new).send(:build_extension_module)   }.not_to raise_error
+    end
+
+    it 'should not allow an extension block with arity != 0' do
+      expect{ resource.extending{|a| def foo; :bar end }.send(:build_extension_module) }.to raise_error(ArgumentError)
+      expect{ resource.extending{    def foo; :bar end }.send(:build_extension_module) }.not_to raise_error
+    end
+
+    it 'should define operations on an extension module' do
+      mod = resource.extending{ def foo; :bar end }.send(:build_extension_module)
+      expect(mod).to be_a(Module)
+      expect(mod).to be_method_defined(:foo)
+      expect(Object.new.tap{|x| x.extend mod }.foo).to eq(:bar)
+      expect(resource).not_to respond_to(:foo)
+      expect(mod).not_to respond_to(:foo)
+    end
+  end
+
+  describe '#subresource()' do
+    subject do
+      lambda{|n,b,e| resource.subresource(n, b, &e).send(:build_extension_module) }
+    end
+    
+    let(:receiver) { double() }
+		let(:model) { double(to_param: '1') }
+    
+    it 'should not be allowed to override an operation' do
+      resource.send(:operations_values) << [:all, lambda{||}]
+      expect { subject[:all, void, void] }.to raise_error(ArgumentError, ":all has already been defined as an operation")
+    end
+
+    it 'must be identified by a Symbol or String' do
+      expect { subject[1, void, void] }.to raise_error(ArgumentError)
+      expect { subject[nil, void, void] }.to raise_error(ArgumentError)
+    end
+
+    it 'must be implemented by a Proc' do
+      expect { subject[1, :get, void] }.to raise_error(ArgumentError)
+      expect { subject[nil, 'get', void] }.to raise_error(ArgumentError)
+    end
+
+    it 'should not require an extension block' do
+      expect { subject[:all, void, nil] }.not_to raise_error
+    end
+
+    it 'should not allow an extension block with arity != 0' do
+      expect { subject[:all, void, void] }.not_to raise_error
+      expect { subject[:all, void, lambda{|a| }] }.to raise_error(ArgumentError)
+    end
+    
+    shared_examples 'building with ResourceBuilder' do
+		  let!(:implementation_block) { lambda{|x| path(x.to_param) } }
+		  
+		  let!(:extension_block){}
+		    
+		  let! :subresource do
+		    resource.subresource(:instance, implementation_block, &extension_block).send(:build_extension_module)
+		  end
+		    
+		  subject! do
+		    subresource
+		  end
+
+      # FYI - Something roughly similar would be done by "a" or "the" proxy/builder.
+		  let :receiver do
+		    Cardiac::ResourceBuilder.new(resource)
+		  end
+		  
+		  let! :result do
+		    expect_any_instance_of(Cardiac::Subresource).to receive(:path).with("1").and_call_original
+		    expect(model).to receive(:to_param).with(no_args)
+		    receiver.instance(model)
+		  end
+			
+			it 'is included on the Resource extension module' do
+		    is_expected.to be_a(Module)
+		    is_expected.not_to respond_to(:instance)
+			end
+
+			# FIXME: not critical, but it would be nice to define them correctly instead of _sufficiently_
+		  it 'defines method arities sufficiently' do
+		    expect([1,-1]).to be_include(subject.instance_method(:instance).arity)
+		  end
+		    
+		  it 'does not extend the Resource' do
+		    expect(resource).not_to respond_to(:instance)
+		  end
+			
+		  it 'is an instance method' do
+		    is_expected.to be_method_defined(:instance)
+		  end
+		  
+		  it 'returns a builder' do
+		    expect(result).to be_a(Cardiac::ResourceBuilder)
+		  end
+		    
+		  it 'does not extend the builder with the subresource method' do
+				expect(result).not_to respond_to(:instance)
+		  end
+		  
+		  it 'builds a subresource on the builder' do
+				expect(result.to_resource.to_uri.path).to eq('/prefix/segment/suffix/1')
+		  end
+		  
+		  it 'does not build on the resource' do
+				expect(resource.to_uri.path).to eq('/prefix/segment/suffix')
+			end
+    end
+    
+    shared_examples 'building and extending with ResourceBuilder' do |ext_name|
+      include_examples 'building with ResourceBuilder'
+      
+      let(:subresult) { result.__send__(ext_name) }
+      
+      it 'extends the builder with the extension method' do
+        expect(result).to respond_to(ext_name)
+      end
+      
+      it 'returns a new builder from the extension method' do
+		    expect(subresult).to be_a(Cardiac::ResourceBuilder)
+      end
+    end
+
+		describe 'without an extension block' do
+		  include_examples 'building with ResourceBuilder'
+		end
+
+		describe 'with an extension method' do
+		  include_examples 'building and extending with ResourceBuilder', :foo do
+		    let(:extension_block) { proc { def foo ; https ; end } }
+		  end
+      
+		  it 'applies the extension block to the subresource on the builder' do
+				subr = subresult.to_resource
+				expect(subr.to_uri.path).to eq('/prefix/segment/suffix/1')
+				expect(resource.to_uri.path).to eq('/prefix/segment/suffix')
+				expect(subresult.to_resource.to_uri.scheme).to eq('https')
+				expect(resource.to_uri.scheme).to eq('http')
+		  end
+		end
+		
+		describe 'with an extension operation' do
+		  include_examples 'building and extending with ResourceBuilder', :foo do
+		    let(:extension_block) { proc { operation :foo, lambda{|| https } } }
+		  end
+
+		  # FIXME: this does not pass due to builder semantics, but the analogue
+		  # works correctly with subresources - see spec/cardiac/model/base_spec.rb		    
+		  #it 'does not extend the new builder with the operation' do
+			#	subresult.should_not respond_to(:foo)
+		  #end
+      
+		  it 'applies the extension block to the subresource on the builder' do
+				subr = subresult.to_resource
+				expect(subr.to_uri.path).to eq('/prefix/segment/suffix/1')
+				expect(resource.to_uri.path).to eq('/prefix/segment/suffix')
+				expect(subresult.to_resource.to_uri.scheme).to eq('https')
+				expect(resource.to_uri.scheme).to eq('http')
+		  end
+		end
+  end
+
+end

data/spec/shared/cardiac/resource/request_methods_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe Cardiac::RequestMethods do
+  
+  let(:base_url) { 'http://localhost/prefix/segment?q=foobar' }
+  let(:base_uri) { URI(base_url) }
+  let(:resource) { Cardiac::Resource.new(base_uri) }
+  let(:default_headers) { {:accepts => Cardiac::RequestMethods::DEFAULT_ACCEPTS } }
+    
+  subject { resource }
+
+  describe 'headers built with' do
+    subject do
+      lambda{|*v| builder[resource, *v] ; resource.send(:build_headers).symbolize_keys.except(:accepts) }
+    end
+    
+    after :each do
+      headers = resource.send(:build_headers)
+      expect(resource.reset_headers.send(:build_headers)).to eq(default_headers)
+      expect(resource.headers(headers).send(:build_headers)).to eq(headers)
+    end
+    
+    shared_examples 'header building' do |builder|
+      let(:builder) { builder }
+      
+      describe "[{content_type: 'application/xml'}]" do
+        subject { super()[{content_type: 'application/xml'}] }
+        it { is_expected.to eq({content_type: 'application/xml'}) }
+      end
+      
+      describe "[{content_type: 'application/xml'},{content_type: 'application/json'}]" do
+        subject { super()[{content_type: 'application/xml'},{content_type: 'application/json'}] }
+
+        it 'has 1 item' do
+        is_expected.to eq({content_type: 'application/json'})
+        expect(subject.size).to eq(1)
+      end
+      end
+      
+      describe "[{'content_type' => 'application/json'},{content_type: 'application/xml'}]" do
+        subject { super()[{'content_type' => 'application/json'},{content_type: 'application/xml'}] }
+
+        it 'has 1 item' do
+        is_expected.to eq({content_type: 'application/xml'})
+        expect(subject.size).to eq(1)
+      end
+      end
+    end
+    
+    describe '#headers()' do
+      include_examples 'header building', lambda{|r,*v| r.headers(*v) }
+        
+      describe "[{content_type: 'application/xml'},{content_type: false}]" do
+        subject { super()[{content_type: 'application/xml'},{content_type: false}] }
+        it { is_expected.to eq({content_type: false}) }
+      end
+    end
+    
+    describe '#header()' do
+      let(:builder) { lambda{|r,*l| l.each{|k,v| r.header(k,v) } } }
+      
+      describe "[[:content_type, 'application/xml']]" do
+        subject { super()[[:content_type, 'application/xml']] }
+        it { is_expected.to eq({content_type: 'application/xml'}) }
+      end
+
+      describe "[['content_type', 'application/json']]" do
+        subject { super()[['content_type', 'application/json']] }
+        it { is_expected.to eq({content_type: 'application/json'}) }
+      end
+
+      describe "[[:content_type, 'application/json'],['content_type', false]]" do
+        subject { super()[[:content_type, 'application/json'],['content_type', false]] }
+        it { is_expected.to eq({}) }
+      end
+
+      describe "[['content_type', 'application/json'],[:content_type, false]]" do
+        subject { super()[['content_type', 'application/json'],[:content_type, false]] }
+        it { is_expected.to eq({}) }
+      end
+
+      describe "[[:content_type, false],[:content_type, 'application/xml']]" do
+        subject { super()[[:content_type, false],[:content_type, 'application/xml']] }
+        it { is_expected.to eq({content_type: 'application/xml'}) }
+      end
+
+      describe "[['content_type', false],['content_type', 'application/json']]" do
+        subject { super()[['content_type', false],['content_type', 'application/json']] }
+        it { is_expected.to eq({content_type: 'application/json'}) }
+      end
+      
+      describe "[[:content_type,'application/xml'],[:content_type,'application/json']]" do
+        subject { super()[[:content_type,'application/xml'],[:content_type,'application/json']] }
+
+        it 'has 1 item' do
+        is_expected.to eq({content_type: 'application/json'})
+        expect(subject.size).to eq(1)
+      end
+      end
+      
+      describe "[['content_type', 'application/json'],[:content_type,'application/xml']]" do
+        subject { super()[['content_type', 'application/json'],[:content_type,'application/xml']] }
+
+        it 'has 1 item' do
+        is_expected.to eq({content_type: 'application/xml'})
+        expect(subject.size).to eq(1)
+      end
+      end
+    end
+    
+    describe '#options()' do
+      include_examples 'header building', lambda{|r,*l| l.each{|o| r.options(headers: o) } }
+        
+      describe "[{content_type: 'application/xml'},{content_type: false}]" do
+        subject { super()[{content_type: 'application/xml'},{content_type: false}] }
+        it { is_expected.to eq({content_type: false}) }
+      end
+    end
+  end
+  
+  describe 'options built with' do
+    subject do
+      lambda{|*v| builder[resource, *v] ; resource.send(:build_options) }
+    end
+    
+    after(:each) do
+      options = resource.send(:build_options)
+      expect(resource.reset_options.send(:build_options)).to eq({})
+      expect(resource.options(options).send(:build_options)).to eq(options)
+    end
+    
+    describe '#options()' do
+      let(:builder){ lambda{|r,*v| r.options(*v) } }
+      
+      describe '[{timeout: 60}]' do
+        subject { super()[{timeout: 60}] }
+        it { is_expected.to eq({timeout: 60}) }
+      end
+      
+      describe '[{timeout: 60},{timeout: 30}]' do
+        subject { super()[{timeout: 60},{timeout: 30}] }
+
+        it 'has 1 item' do
+        is_expected.to eq({timeout: 30})
+        expect(subject.size).to eq(1)
+      end
+      end
+      
+      describe "[{'timeout' => 60},{timeout: 30}]" do
+        subject { super()[{'timeout' => 60},{timeout: 30}] }
+
+        it 'has 1 item' do
+        is_expected.to eq({timeout: 30})
+        expect(subject.size).to eq(1)
+      end
+      end
+    end
+    
+    describe '#option()' do
+      let(:builder){ lambda{|r,*l| l.each{|k,v| r.option(k,v) } } }
+  
+      describe '[[:timeout, 60]]' do
+        subject { super()[[:timeout, 60]] }
+        it { is_expected.to eq({timeout: 60}) }
+      end
+        
+      describe '[[:timeout, 60],[:timeout, 30]]' do
+        subject { super()[[:timeout, 60],[:timeout, 30]] }
+
+        it 'has 1 item' do
+        is_expected.to eq({timeout: 30})
+        expect(subject.size).to eq(1)
+      end
+      end
+      
+      describe "[['timeout',  60],[:timeout, 30]]" do
+        subject { super()[['timeout',  60],[:timeout, 30]] }
+
+        it 'has 1 item' do
+        is_expected.to eq({timeout: 30})
+        expect(subject.size).to eq(1)
+      end
+      end
+    end
+  end
+end

data/spec/shared/cardiac/resource/uri_methods_spec.rb

@@ -0,0 +1,212 @@
+require 'spec_helper'
+
+describe Cardiac::UriMethods do
+  
+  let(:base_url) { 'http://localhost/prefix/segment?q=foobar' }
+  let(:base_uri) { URI(base_url) }
+  let(:resource) { Cardiac::Resource.new(base_uri) }
+    
+  subject { resource }
+    
+  describe '#build_query' do
+    subject { super().send(:build_query) }
+    it { is_expected.to eq('q=foobar')}
+  end
+
+  describe '#to_url' do
+    subject { super().to_url }
+    it { is_expected.to eq(base_url) }
+  end
+
+  describe '#to_uri' do
+    subject { super().to_uri }
+    it { is_expected.to eq(base_uri) }
+  end
+    
+  describe 'scheme built with' do
+    # Follow each example with sanity checks.
+    after(:each) do 
+      scheme = resource.send(:build_scheme)
+      expect(resource.scheme(nil).to_uri.scheme).to eq(base_uri.scheme)
+      expect(resource.scheme(scheme).to_uri.scheme).to eq(scheme)
+    end
+        
+    describe '#scheme()' do
+      subject { lambda{|v| resource.scheme(v).to_uri.scheme } }
+        
+      describe '[:http]' do
+        subject { super()[:http] }
+        it { is_expected.to eq('http') }
+      end
+
+      describe "['http']" do
+        subject { super()['http'] }
+        it { is_expected.to eq('http') }
+      end
+
+      describe '[:https]' do
+        subject { super()[:https] }
+        it { is_expected.to eq('https') }
+      end
+
+      describe "['https']" do
+        subject { super()['https'] }
+        it { is_expected.to eq('https') }
+      end
+
+      describe '[nil]' do
+        subject { super()[nil] }
+        it { is_expected.to eq(base_uri.scheme) }
+      end
+        
+      it 'disallows invalid schemes' do
+        expect { subject['ftp']   }.to raise_error(ArgumentError)
+        expect { subject[0]       }.to raise_error(ArgumentError)
+        expect { subject[:mailto] }.to raise_error(ArgumentError)
+        expect { subject[false]   }.to raise_error(ArgumentError)
+      end
+    end
+    describe '#ssl()' do
+      subject { lambda{|v| resource.ssl(v).to_uri.scheme } }
+
+      describe '[false]' do
+        subject { super()[false] }
+        it { is_expected.to eq('http') }
+      end
+
+      describe '[true]' do
+        subject { super()[true] }
+        it { is_expected.to eq('https') }
+      end
+
+      describe '[nil]' do
+        subject { super()[nil] }
+        it { is_expected.to eq(base_uri.scheme) }
+      end
+    end
+    describe '#http()' do
+      subject { lambda{|| resource.http.to_uri.scheme } }
+
+      describe '[]' do
+        subject { super()[] }
+        it { is_expected.to eq('http') }
+      end
+    end
+    describe '#https()' do
+      subject { lambda{|| resource.https.to_uri.scheme } }
+
+      describe '[]' do
+        subject { super()[] }
+        it { is_expected.to eq('https') }
+      end
+    end
+  end
+  
+  describe 'query built with' do
+    subject do
+      lambda{|*v| builder[resource, *v] ; resource.send(:build_query) }
+    end
+    
+    # Follow each example with sanity checks.
+    after(:each) do 
+      query = resource.send(:build_query)
+      expect(resource.reset_query.send(:build_query)).not_to be_present
+      expect(resource.query(query).send(:build_query)).to eq(query)
+    end
+
+    # Shared examples that must work for any query builder.    
+    shared_examples 'query building' do |builder|
+      let(:builder) { builder }
+        
+      describe "['q=1']" do
+        subject { super()['q=1'] }
+        it { is_expected.to eq('q=1') }
+      end
+
+      describe "['q=4&r=3','s=2&t=1']" do
+        subject { super()['q=4&r=3','s=2&t=1'] }
+        it { is_expected.to eq('q=4&r=3&s=2&t=1') }
+      end
+
+      describe "[{q: 3, s: 1}, 'r=2&t=1']" do
+        subject { super()[{q: 3, s: 1}, 'r=2&t=1'] }
+        it { is_expected.to eq('q=3&s=1&r=2&t=1') }
+      end
+
+      describe "['q=1&t=4',{r: 2, s: 3}]" do
+        subject { super()['q=1&t=4',{r: 2, s: 3}] }
+        it { is_expected.to eq('q=1&t=4&r=2&s=3') }
+      end
+        
+      it 'disallows invalid queries' do
+        expect { subject[%w(a b c)]   }.to raise_error(ArgumentError)
+        expect { subject[0]           }.to raise_error(ArgumentError)
+        expect { subject[:mailto]     }.to raise_error(ArgumentError)
+        expect { subject[false]       }.to raise_error(ArgumentError)
+      end
+      
+      it 'does not modify queries built with a single argument' do
+        resource.reset_query
+        expect(subject['q=1&q=2']).to eq('q=1&q=2')
+        resource.reset_query
+        expect(subject['q=1&r=1&q=2']).to eq('q=1&r=1&q=2')
+      end
+      
+      it 'does modify queries built with two or more arguments' do
+        resource.reset_query
+        expect(subject['q=1&q=2', 'r=1']).to eq('q=2&r=1')
+        resource.reset_query
+        expect(subject['q=1&r=1&q=2', 'r=2']).to eq('q=2&r=2')
+        resource.reset_query
+        expect(subject['q=1&r=1&q=2', 'r=2&q=3']).to eq('q=3&r=2')
+      end
+    end
+        
+    describe '#query()' do
+      include_examples 'query building', Proc.new{|r,*v| r.query(*v) }
+    end
+
+    describe '#options()' do
+      include_examples 'query building', Proc.new{|r,*l| l.each{|o| r.options(params: o) } }
+        
+      after(:each) { expect(resource.options_values).to be_empty }
+    end
+  end 
+   
+  it 'sets the host' do
+    expect(subject.host('example.com').to_uri.host).to eq('example.com')
+    expect(subject.host('127.0.0.1').to_uri.host).to eq('127.0.0.1')
+  end
+    
+  it 'sets the port for HTTP' do
+    expect(subject.http.to_uri.port).to eq(80)
+    expect(subject.http.port(8080).to_uri.port).to eq(8080)
+    expect(subject.http.port(nil).to_uri.port).to eq(80)
+  end
+    
+  it 'sets the port for HTTPS' do
+    expect(subject.https.to_uri.port).to eq(443)
+    expect(subject.https.port(8080).to_uri.port).to eq(8080)
+    expect(subject.https.port(nil).to_uri.port).to eq(443)
+  end
+    
+  it 'merges query parameters' do
+    expect(subject.query(q: 'barfoo').to_uri.query).to eq('q=barfoo')
+    expect(subject.query(q: '1', t: '2').to_uri.query).to eq('q=1&t=2')
+    expect(subject.reset_query(t: '3').query(q: 1).query(t: 2).to_uri.query).to eq('t=2&q=1')
+    expect(subject.reset_query(q: 'foobar').options(params: {r: 2, s: 'barfoo'}).to_uri.query).to eq('q=foobar&r=2&s=barfoo')
+  end
+    
+  it 'deep_merges query parameters' do
+    expect(subject.query(q: {r: 1}).to_uri.query).to eq('q[r]=1')
+    expect(subject.query(q: {s: 2}).to_uri.query).to eq('q[r]=1&q[s]=2')
+    expect(subject.query('q'=>{t: 3}).to_uri.query).to eq('q[r]=1&q[s]=2&q[t]=3')
+  end
+    
+  it 'resolves relative paths' do
+    expect(subject.path('suffix').to_url).to eq('http://localhost/prefix/suffix?q=foobar')
+    expect(subject.path('/suffix').to_url).to eq('http://localhost/suffix?q=foobar')
+    expect(subject.path('../suffix').to_url).to eq('http://localhost/suffix?q=foobar')
+    expect(subject.path('suffix/../addendum').to_url).to eq('http://localhost/addendum?q=foobar')
+  end
+end

data/spec/shared/support/client_execution.rb

@@ -0,0 +1,28 @@
+shared_context 'Client responses' do
+  
+  let!(:mock_response_klass) { Struct.new(:body, :code, :headers) }
+  
+  let!(:mock_success) { mock_response_klass.new("{\"segment\" : {\"id\": 1, \"name\": \"John Doe\"}}", 
+                                               200, 'Content-type' => 'application/json') }
+    
+  let!(:mock_failure) { mock_response_klass.new("<html><head><title>Failed</title></head><body><h1>Failed</h1></body></html>",
+                                               404, 'Content-type' => 'text/html') }
+  
+  let!(:response_builder) { Proc.new{|mock,*args|
+    mock = send(:"mock_#{mock}") if Symbol===mock
+    Rack::Client::Simple::CollapsedResponse.new(mock.code, mock.headers, StringIO.new(mock.body))
+  } } 
+  
+  let!(:response_handler) { Proc.new{|mock,args|
+    response_builder[mock, args]
+  } }
+  
+end
+
+shared_context 'Client execution' do |verb,mock_response|
+  before :example do
+    allow_any_instance_of(Cardiac::OperationHandler).to receive(:perform_request) do
+      response_handler[mock_response]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+# Configure Rails Environment
+ENV["RAILS_ENV"] ||= "test"
+
+require 'active_support/all'
+require 'active_model'
+require 'cardiac'
+
+require 'awesome_print'
+
+require 'rspec/core'
+
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each {|f| require f}
+  
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # 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'
+end