puppet 3.6.2 → 3.7.0

data/spec/unit/module_tool/applications/uninstaller_spec.rb

@@ -113,6 +113,28 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
       end
     end
 
+    context 'with --ignore-changes' do
+      def options
+        super.merge(:ignore_changes => true)
+      end
+
+      context 'with local changes' do
+        before do
+          mark_changed(File.join(primary_dir, 'stdlib'))
+        end
+
+        it 'overwrites the installed module with the greatest version matching that range' do
+          subject.should include :result => :success
+        end
+      end
+
+      context 'without local changes' do
+        it 'overwrites the installed module with the greatest version matching that range' do
+          subject.should include :result => :success
+        end
+      end
+    end
+
     context "when using the --force flag" do
 
       def options

data/spec/unit/module_tool/applications/unpacker_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'json'
 
 require 'puppet/module_tool/applications'
+require 'puppet/file_system'
 require 'puppet_spec/modules'
 
 describe Puppet::ModuleTool::Applications::Unpacker do
@@ -31,4 +32,43 @@ describe Puppet::ModuleTool::Applications::Unpacker do
     Puppet::ModuleTool::Applications::Unpacker.run(filename, :target_dir => target)
     File.should be_directory(File.join(target, 'mytarball'))
   end
+
+  it "should warn about symlinks", :if => Puppet.features.manages_symlinks? do
+    untar = mock('Tar')
+    untar.expects(:unpack).with(filename, anything()) do |src, dest, _|
+      FileUtils.mkdir(File.join(dest, 'extractedmodule'))
+      File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
+        file.puts JSON.generate('name' => module_name, 'version' => '1.0.0')
+      end
+      FileUtils.touch(File.join(dest, 'extractedmodule/tempfile'))
+      Puppet::FileSystem.symlink(File.join(dest, 'extractedmodule/tempfile'), File.join(dest, 'extractedmodule/tempfile2'))
+      true
+    end
+
+    Puppet::ModuleTool::Tar.expects(:instance).returns(untar)
+    Puppet.expects(:warning).with(regexp_matches(/symlinks/i))
+
+    Puppet::ModuleTool::Applications::Unpacker.run(filename, :target_dir => target)
+    File.should be_directory(File.join(target, 'mytarball'))
+  end
+
+  it "should warn about symlinks in subdirectories", :if => Puppet.features.manages_symlinks? do
+    untar = mock('Tar')
+    untar.expects(:unpack).with(filename, anything()) do |src, dest, _|
+      FileUtils.mkdir(File.join(dest, 'extractedmodule'))
+      File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
+        file.puts JSON.generate('name' => module_name, 'version' => '1.0.0')
+      end
+      FileUtils.mkdir(File.join(dest, 'extractedmodule/manifests'))
+      FileUtils.touch(File.join(dest, 'extractedmodule/manifests/tempfile'))
+      Puppet::FileSystem.symlink(File.join(dest, 'extractedmodule/manifests/tempfile'), File.join(dest, 'extractedmodule/manifests/tempfile2'))
+      true
+    end
+
+    Puppet::ModuleTool::Tar.expects(:instance).returns(untar)
+    Puppet.expects(:warning).with(regexp_matches(/symlinks/i))
+
+    Puppet::ModuleTool::Applications::Unpacker.run(filename, :target_dir => target)
+    File.should be_directory(File.join(target, 'mytarball'))
+  end
 end

data/spec/unit/module_tool/applications/upgrader_spec.rb

@@ -52,6 +52,16 @@ describe Puppet::ModuleTool::Applications::Upgrader do
     end
 
     context 'for an installed module' do
+      context 'with only one version' do
+        before { preinstall('puppetlabs-oneversion', '0.0.1') }
+        let(:module) { 'puppetlabs-oneversion' }
+
+        it 'declines to upgrade' do
+          subject.should include :result => :noop
+          subject[:error][:multiline].should =~ /already the latest version/
+        end
+      end
+
       context 'without dependencies' do
         before { preinstall('pmtacceptance-stdlib', '1.0.0') }
 
@@ -90,6 +100,7 @@ describe Puppet::ModuleTool::Applications::Upgrader do
               context 'without options' do
                 it 'declines to upgrade' do
                   subject.should include :result => :noop
+                  subject[:error][:multiline].should =~ /already the latest version/
                 end
               end
 
@@ -165,6 +176,17 @@ describe Puppet::ModuleTool::Applications::Upgrader do
           subject.should include :result => :failure
           subject[:error].should include :oneline => "Could not upgrade '#{self.module}'; module has had changes made locally"
         end
+
+        context 'with --ignore-changes' do
+          def options
+            super.merge(:ignore_changes => true)
+          end
+
+          it 'overwrites the installed module with the greatest version matching that range' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-stdlib', v('1.0.0') => v('4.1.0')
+          end
+        end
       end
 
       context 'with dependencies' do

data/spec/unit/module_tool/installed_modules_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'puppet/module_tool/installed_modules'
+require 'puppet_spec/modules'
+
+describe Puppet::ModuleTool::InstalledModules do
+  include PuppetSpec::Files
+
+  around do |example|
+    dir = tmpdir("deep_path")
+
+    FileUtils.mkdir_p(@modpath = File.join(dir, "modpath"))
+
+    @env = Puppet::Node::Environment.create(:env, [@modpath])
+    Puppet.override(:current_environment => @env) do
+      example.run
+    end
+  end
+
+  it 'works when given a semantic version' do
+    mod = PuppetSpec::Modules.create('goodsemver', @modpath, :metadata => {:version => '1.2.3'})
+    installed = described_class.new(@env)
+    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(Semantic::Version.parse('1.2.3'))
+  end
+
+  it 'defaults when not given a semantic version' do
+    mod = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => 'banana'})
+    Puppet.expects(:warning).with(regexp_matches(/Semantic Version/))
+    installed = described_class.new(@env)
+    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(Semantic::Version.parse('0.0.0'))
+  end
+
+  it 'defaults when not given a full semantic version' do
+    mod = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => '1.2'})
+    Puppet.expects(:warning).with(regexp_matches(/Semantic Version/))
+    installed = described_class.new(@env)
+    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(Semantic::Version.parse('0.0.0'))
+  end
+
+  it 'still works if there is an invalid version in one of the modules' do
+    mod1 = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => 'banana'})
+    mod2 = PuppetSpec::Modules.create('goodsemver', @modpath, :metadata => {:version => '1.2.3'})
+    mod3 = PuppetSpec::Modules.create('notquitesemver', @modpath, :metadata => {:version => '1.2'})
+    Puppet.expects(:warning).with(regexp_matches(/Semantic Version/)).twice
+    installed = described_class.new(@env)
+    expect(installed.modules["puppetlabs-#{mod1.name}"].version).to eq(Semantic::Version.parse('0.0.0'))
+    expect(installed.modules["puppetlabs-#{mod2.name}"].version).to eq(Semantic::Version.parse('1.2.3'))
+    expect(installed.modules["puppetlabs-#{mod3.name}"].version).to eq(Semantic::Version.parse('0.0.0'))
+  end
+end

data/spec/unit/module_tool/metadata_spec.rb

@@ -5,6 +5,19 @@ describe Puppet::ModuleTool::Metadata do
   let(:data) { {} }
   let(:metadata) { Puppet::ModuleTool::Metadata.new }
 
+  describe 'property lookups' do
+    subject { metadata }
+
+    %w[ name version author summary license source project_page issues_url
+    dependencies dashed_name release_name description ].each do |prop|
+      describe "##{prop}" do
+        it "responds to the property" do
+          subject.send(prop)
+        end
+      end
+    end
+  end
+
   describe "#update" do
     subject { metadata.update(data) }
 
@@ -156,6 +169,61 @@ describe Puppet::ModuleTool::Metadata do
 
     end
 
+    context "with a valid dependency" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-goodmodule'}] }}
+
+      it "adds the dependency" do
+        subject.dependencies.size.should == 1
+      end
+    end
+
+    context "with a invalid dependency name" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabsbadmodule'}] }}
+
+      it "raises an exception" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "with a valid dependency version range" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-badmodule', 'version_requirement' => '>= 2.0.0'}] }}
+
+      it "adds the dependency" do
+        subject.dependencies.size.should == 1
+      end
+    end
+
+    context "with a invalid version range" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabsbadmodule', 'version_requirement' => '>= banana'}] }}
+
+      it "raises an exception" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "with duplicate dependencies" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-dupmodule', 'version_requirement' => '1.0.0'},
+        {'name' => 'puppetlabs-dupmodule', 'version_requirement' => '0.0.1'}] }
+      }
+
+      it "raises an exception" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "adding a duplicate dependency" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-origmodule', 'version_requirement' => '1.0.0'}] }}
+
+      it "with a different version raises an exception" do
+        metadata.add_dependency('puppetlabs-origmodule', '>= 0.0.1')
+        expect { subject }.to raise_error(ArgumentError)
+      end
+
+      it "with the same version does not add another dependency" do
+        metadata.add_dependency('puppetlabs-origmodule', '1.0.0')
+        subject.dependencies.size.should == 1
+      end
+    end
   end
 
   describe '#dashed_name' do
@@ -202,8 +270,8 @@ describe Puppet::ModuleTool::Metadata do
   describe "#to_hash" do
     subject { metadata.to_hash }
 
-    its(:keys) do
-      subject.sort.should == %w[ name version author summary license source issues_url project_page dependencies ].sort
+    it "contains the default set of keys" do
+      subject.keys.sort.should == %w[ name version author summary license source issues_url project_page dependencies ].sort
     end
 
     describe "['license']" do
@@ -213,8 +281,8 @@ describe Puppet::ModuleTool::Metadata do
     end
 
     describe "['dependencies']" do
-      it "defaults to an empty Array" do
-        subject['dependencies'].should == []
+      it "defaults to an empty set" do
+        subject['dependencies'].should == Set.new
       end
     end
 

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -54,6 +54,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     reader = mock('GzipReader')
 
     Zlib::GzipReader.expects(:open).with(sourcefile).yields(reader)
-    Archive::Tar::Minitar.expects(:unpack).with(reader, destdir).yields(type, name, nil)
+    minitar.expects(:find_valid_files).with(reader).returns([name])
+    Archive::Tar::Minitar.expects(:unpack).with(reader, destdir, [name]).yields(type, name, nil)
   end
 end

data/spec/unit/network/authentication_spec.rb

@@ -81,6 +81,10 @@ describe Puppet::Network::Authentication do
         cert.stubs(:unmunged_name).returns('foo')
       end
 
+      after(:all) do
+        reload_module
+      end
+
       it "should log a warning if a certificate's expiration is near" do
         logger.expects(:warning)
         subject.warn_if_near_expiration(cert)

data/spec/unit/network/http/api/v2/environments_spec.rb

@@ -23,20 +23,41 @@ describe Puppet::Network::HTTP::API::V2::Environments do
         "production" => {
           "settings" => {
             "modulepath" => [File.expand_path("/first"), File.expand_path("/second")],
-            "manifest" => File.expand_path("/manifests")
+            "manifest" => File.expand_path("/manifests"),
+            "environment_timeout" => 0,
+            "config_version" => ""
           }
         }
       }
     })
   end
 
-  it "the response conforms to the environments schema" do
+  it "the response conforms to the environments schema for unlimited timeout" do
+    conf_stub = stub 'conf_stub'
+    conf_stub.expects(:environment_timeout).returns(1.0 / 0.0)
     environment = Puppet::Node::Environment.create(:production, [])
-    handler = Puppet::Network::HTTP::API::V2::Environments.new(Puppet::Environments::Static.new(environment))
+    env_loader = Puppet::Environments::Static.new(environment)
+    env_loader.expects(:get_conf).with(:production).returns(conf_stub)
+    handler = Puppet::Network::HTTP::API::V2::Environments.new(env_loader)
     response = Puppet::Network::HTTP::MemoryResponse.new
 
     handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end
+
+  it "the response conforms to the environments schema for integer timeout" do
+    conf_stub = stub 'conf_stub'
+    conf_stub.expects(:environment_timeout).returns(1)
+    environment = Puppet::Node::Environment.create(:production, [])
+    env_loader = Puppet::Environments::Static.new(environment)
+    env_loader.expects(:get_conf).with(:production).returns(conf_stub)
+    handler = Puppet::Network::HTTP::API::V2::Environments.new(env_loader)
+    response = Puppet::Network::HTTP::MemoryResponse.new
+
+    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+
+    expect(response.body).to validate_against('api/schemas/environments.json')
+  end
+
 end

data/spec/unit/network/http/connection_spec.rb

@@ -11,50 +11,30 @@ describe Puppet::Network::HTTP::Connection do
   let (:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
   context "when providing HTTP connections" do
-    after do
-      Puppet::Network::HTTP::Connection.instance_variable_set("@ssl_host", nil)
-    end
-
     context "when initializing http instances" do
-      before :each do
-        # All of the cert stuff is tested elsewhere
-        Puppet::Network::HTTP::Connection.stubs(:cert_setup)
-      end
-
       it "should return an http instance created with the passed host and port" do
-        http = subject.send(:connection)
-        http.should be_an_instance_of Net::HTTP
-        http.address.should == host
-        http.port.should    == port
+        conn = Puppet::Network::HTTP::Connection.new(host, port, :verify => Puppet::SSL::Validator.no_validator)
+
+        expect(conn.address).to eq(host)
+        expect(conn.port).to eq(port)
       end
 
       it "should enable ssl on the http instance by default" do
-        http = subject.send(:connection)
-        http.should be_use_ssl
-      end
+        conn = Puppet::Network::HTTP::Connection.new(host, port, :verify => Puppet::SSL::Validator.no_validator)
 
-      it "can set ssl using an option" do
-        Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator).send(:connection).should_not be_use_ssl
-        Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => true, :verify => Puppet::SSL::Validator.no_validator).send(:connection).should be_use_ssl
+        expect(conn).to be_use_ssl
       end
 
-      context "proxy and timeout settings should propagate" do
-        subject { Puppet::Network::HTTP::Connection.new(host, port, :verify => Puppet::SSL::Validator.no_validator).send(:connection) }
-        before :each do
-          Puppet[:http_proxy_host] = "myhost"
-          Puppet[:http_proxy_port] = 432
-          Puppet[:configtimeout]   = 120
-        end
+      it "can disable ssl using an option" do
+        conn = Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator)
 
-        its(:open_timeout)  { should == Puppet[:configtimeout] }
-        its(:read_timeout)  { should == Puppet[:configtimeout] }
-        its(:proxy_address) { should == Puppet[:http_proxy_host] }
-        its(:proxy_port)    { should == Puppet[:http_proxy_port] }
+        expect(conn).to_not be_use_ssl
       end
 
-      it "should not set a proxy if the value is 'none'" do
-        Puppet[:http_proxy_host] = 'none'
-        subject.send(:connection).proxy_address.should be_nil
+      it "can enable ssl using an option" do
+        conn = Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => true, :verify => Puppet::SSL::Validator.no_validator)
+
+        expect(conn).to be_use_ssl
       end
 
       it "should raise Puppet::Error when invalid options are specified" do
@@ -96,7 +76,44 @@ describe Puppet::Network::HTTP::Connection do
     end
   end
 
-  context "when validating HTTPS requests" do
+  class ConstantErrorValidator
+    def initialize(args)
+      @fails_with = args[:fails_with]
+      @error_string = args[:error_string] || ""
+      @peer_certs = args[:peer_certs] || []
+    end
+
+    def setup_connection(connection)
+      connection.stubs(:start).raises(OpenSSL::SSL::SSLError.new(@fails_with))
+    end
+
+    def peer_certs
+      @peer_certs
+    end
+
+    def verify_errors
+      [@error_string]
+    end
+  end
+
+  class NoProblemsValidator
+    def initialize(cert)
+      @cert = cert
+    end
+
+    def setup_connection(connection)
+    end
+
+    def peer_certs
+      [@cert]
+    end
+
+    def verify_errors
+      []
+    end
+  end
+
+  shared_examples_for 'ssl verifier' do
     include PuppetSpec::Files
 
     let (:host) { "my_server" }
@@ -117,11 +134,11 @@ describe Puppet::Network::HTTP::Connection do
       Puppet[:confdir] = tmpdir('conf')
 
       connection = Puppet::Network::HTTP::Connection.new(
-        host, port,
-        :verify => ConstantErrorValidator.new(
-          :fails_with => 'hostname was not match with server certificate',
-          :peer_certs => [Puppet::SSL::CertificateAuthority.new.generate(
-            'not_my_server', :dns_alt_names => 'foo,bar,baz')]))
+      host, port,
+      :verify => ConstantErrorValidator.new(
+        :fails_with => 'hostname was not match with server certificate',
+        :peer_certs => [Puppet::SSL::CertificateAuthority.new.generate(
+          'not_my_server', :dns_alt_names => 'foo,bar,baz')]))
 
       expect do
         connection.get('request')
@@ -150,86 +167,104 @@ describe Puppet::Network::HTTP::Connection do
         host, port,
         :verify => NoProblemsValidator.new(cert))
 
+      Net::HTTP.any_instance.stubs(:start)
       Net::HTTP.any_instance.stubs(:request).returns(httpok)
 
       connection.expects(:warn_if_near_expiration).with(cert)
 
       connection.get('request')
     end
+  end
 
-    class ConstantErrorValidator
-      def initialize(args)
-        @fails_with = args[:fails_with]
-        @error_string = args[:error_string] || ""
-        @peer_certs = args[:peer_certs] || []
-      end
+  context "when using single use HTTPS connections" do
+    it_behaves_like 'ssl verifier' do
+    end
+  end
 
-      def setup_connection(connection)
-        connection.stubs(:request).with do
-          true
-        end.raises(OpenSSL::SSL::SSLError.new(@fails_with))
+  context "when using persistent HTTPS connections" do
+    around :each do |example|
+      pool = Puppet::Network::HTTP::Pool.new
+      Puppet.override(:http_pool => pool) do
+        example.run
       end
+      pool.close
+    end
 
-      def peer_certs
-        @peer_certs
-      end
+    it_behaves_like 'ssl verifier' do
+    end
+  end
 
-      def verify_errors
-        [@error_string]
-      end
+  context "when response is a redirect" do
+    let (:site)       { Puppet::Network::HTTP::Site.new('http', 'my_server', 8140) }
+    let (:other_site) { Puppet::Network::HTTP::Site.new('http', 'redirected', 9292) }
+    let (:other_path) { "other-path" }
+    let (:verify) { Puppet::SSL::Validator.no_validator }
+    let (:subject) { Puppet::Network::HTTP::Connection.new(site.host, site.port, :use_ssl => false, :verify => verify) }
+    let (:httpredirection) do
+      response = Net::HTTPFound.new('1.1', 302, 'Moved Temporarily')
+      response['location'] = "#{other_site.addr}/#{other_path}"
+      response.stubs(:read_body).returns("This resource has moved")
+      response
     end
 
-    class NoProblemsValidator
-      def initialize(cert)
-        @cert = cert
-      end
+    def create_connection(site, options)
+      options[:use_ssl] = site.use_ssl?
+      Puppet::Network::HTTP::Connection.new(site.host, site.port, options)
+    end
 
-      def setup_connection(connection)
-      end
+    it "should redirect to the final resource location" do
+      http = stub('http')
+      http.stubs(:request).returns(httpredirection).then.returns(httpok)
 
-      def peer_certs
-        [@cert]
-      end
+      seq = sequence('redirection')
+      pool = Puppet.lookup(:http_pool)
+      pool.expects(:with_connection).with(site, anything).yields(http).in_sequence(seq)
+      pool.expects(:with_connection).with(other_site, anything).yields(http).in_sequence(seq)
 
-      def verify_errors
-        []
-      end
+      conn = create_connection(site, :verify => verify)
+      conn.get('/foo')
     end
-  end
 
-  context "when response is a redirect" do
-    let (:other_host) { "redirected" }
-    let (:other_port) { 9292 }
-    let (:other_path) { "other-path" }
-    let (:subject) { Puppet::Network::HTTP::Connection.new("my_server", 8140, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator) }
-    let (:httpredirection) { Net::HTTPFound.new('1.1', 302, 'Moved Temporarily') }
+    def expects_redirection(conn, &block)
+      http = stub('http')
+      http.stubs(:request).returns(httpredirection)
 
-    before :each do
-      httpredirection['location'] = "http://#{other_host}:#{other_port}/#{other_path}"
-      httpredirection.stubs(:read_body).returns("This resource has moved")
+      pool = Puppet.lookup(:http_pool)
+      pool.expects(:with_connection).with(site, anything).yields(http)
+      pool
+    end
 
-      socket = stub_everything("socket")
-      TCPSocket.stubs(:open).returns(socket)
+    def expects_limit_exceeded(conn)
+      expect {
+        conn.get('/')
+      }.to raise_error(Puppet::Network::HTTP::RedirectionLimitExceededException)
+    end
 
-      Net::HTTP::Get.any_instance.stubs(:exec).returns("")
-      Net::HTTP::Post.any_instance.stubs(:exec).returns("")
+    it "should not redirect when the limit is 0" do
+      conn = create_connection(site, :verify => verify, :redirect_limit => 0)
+
+      pool = expects_redirection(conn)
+      pool.expects(:with_connection).with(other_site, anything).never
+
+      expects_limit_exceeded(conn)
     end
 
-    it "should redirect to the final resource location" do
-      httpok.stubs(:read_body).returns(:body)
-      Net::HTTPResponse.stubs(:read_new).returns(httpredirection).then.returns(httpok)
+    it "should redirect only once" do
+      conn = create_connection(site, :verify => verify, :redirect_limit => 1)
+
+      pool = expects_redirection(conn)
+      pool.expects(:with_connection).with(other_site, anything).once
 
-      subject.get("/foo").body.should == :body
-      subject.port.should == other_port
-      subject.address.should == other_host
+      expects_limit_exceeded(conn)
     end
 
-    it "should raise an error after too many redirections" do
-      Net::HTTPResponse.stubs(:read_new).returns(httpredirection)
+    it "should raise an exception when the redirect limit is exceeded" do
+      conn = create_connection(site, :verify => verify, :redirect_limit => 3)
 
-      expect {
-        subject.get("/foo")
-      }.to raise_error(Puppet::Network::HTTP::RedirectionLimitExceededException)
+      pool = expects_redirection(conn)
+      pool.expects(:with_connection).with(other_site, anything).times(3)
+
+      expects_limit_exceeded(conn)
     end
   end