nginx_test_helper 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75c520d4f170c613f24605612e69088fedb3a219
-  data.tar.gz: a7c16004fb9a1a01a89ff5d331fef4376978c689
+  metadata.gz: 78a4974a32a0e57c0f6dcdf50600c34045085665
+  data.tar.gz: 012ca812a9689d695f1e39761aee4bd595f74eb3
 SHA512:
-  metadata.gz: 706b0d4e95fbfae35443faad3f6916e223e2a8074c2e866fa336689d4c1a7d1231d1d1f3d6662902e8b2d8297c94fc4c2b45f86c57c137ea993ada8f8f89d59f
-  data.tar.gz: 9a843a5c7cb60820a533db67dc3e226d37039d045e19c7ef4ee88bb97b364ee9a15ad2398c632a7ce925832ca30e66774ff8c5d6a36fac0b8d10bb5c07a2c11d
+  metadata.gz: 08f2d07609dea934f5013edfc80bf259402fda0e67170913b4b4a73a7ec7cecaf17b8fc333f2083b43562f15156b86e7ed96af7f52e2316122f2d2956780db10
+  data.tar.gz: 5d61fcb9ce455966da624bcb0833a4bd99c5febffe54b25d5a66a08e634528eecf1b6f3865f8d60ec5db08d28e367cbd6273d79aedba62b08f874e9350096966

data/lib/nginx_test_helper/rspec_utils.rb

@@ -10,6 +10,7 @@ if defined?(RSpec)
     end
 
     config.around(:each) do |ex|
+      Thread.current[:current_example] = ex
       logs = Dir[File.join(NginxTestHelper.nginx_tests_tmp_dir, "logs", "**")]
       error_log_pre = logs.map{|log| File.readlines(log)}.flatten
 
@@ -29,12 +30,22 @@ if defined?(RSpec)
       (actual >= min) && (actual <= max)
     end
 
-    failure_message_for_should do |actual|
-      "expected that #{actual} would be in the interval from #{min} to #{max}"
-    end
+    if RSpec::Core::Version::STRING < "3.0.0"
+      failure_message_for_should do |actual|
+        "expected that #{actual} would be in the interval from #{min} to #{max}"
+      end
+
+      failure_message_for_should_not do |actual|
+        "expected that #{actual} would not be in the interval from #{min} to #{max}"
+      end
+    else
+      failure_message do |actual|
+        "expected that #{actual} would be in the interval from #{min} to #{max}"
+      end
 
-    failure_message_for_should_not do |actual|
-      "expected that #{actual} would not be in the interval from #{min} to #{max}"
+      failure_message_when_negated do |actual|
+        "expected that #{actual} would not be in the interval from #{min} to #{max}"
+      end
     end
 
     description do
@@ -47,12 +58,22 @@ if defined?(RSpec)
       actual.match(pattern)
     end
 
-    failure_message_for_should do |actual|
-      "expected that '#{actual}' would match the pattern '#{pattern.inspect}'"
-    end
+    if RSpec::Core::Version::STRING < "3.0.0"
+      failure_message_for_should do |actual|
+        "expected that '#{actual}' would match the pattern '#{pattern.inspect}'"
+      end
+
+      failure_message_for_should_not do |actual|
+        "expected that '#{actual}' would not match the pattern '#{pattern.inspect}'"
+      end
+    else
+      failure_message do |actual|
+        "expected that '#{actual}' would match the pattern '#{pattern.inspect}'"
+      end
 
-    failure_message_for_should_not do |actual|
-      "expected that '#{actual}' would not match the pattern '#{pattern.inspect}'"
+      failure_message_when_negated do |actual|
+        "expected that '#{actual}' would not match the pattern '#{pattern.inspect}'"
+      end
     end
 
     description do

data/lib/nginx_test_helper/version.rb

@@ -1,3 +1,3 @@
 module NginxTestHelper
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/nginx_test_helper.rb

@@ -106,7 +106,9 @@ module NginxTestHelper
 
 private
   def config_id
-    if self.respond_to?(:example) && !self.example.nil? &&
+    if !Thread.current[:current_example].nil? && Thread.current[:current_example].respond_to?(:location)
+      (Thread.current[:current_example].location.split('/') - [".", "spec"]).join('_').gsub(/[\.\:]/, '_')
+    elsif self.respond_to?(:example) && !self.example.nil? &&
        self.example.respond_to?(:metadata) && !self.example.metadata.nil? &&
        !self.example.metadata[:location].nil?
       (self.example.metadata[:location].split('/') - [".", "spec"]).join('_').gsub(/[\.\:]/, '_')
@@ -118,7 +120,9 @@ private
   end
 
   def has_passed?
-    if self.respond_to?(:example) && !self.example.nil? && self.example.respond_to?(:exception)
+    if !Thread.current[:current_example].nil? && Thread.current[:current_example].respond_to?(:exception)
+      Thread.current[:current_example].exception.nil?
+    elsif self.respond_to?(:example) && !self.example.nil? && self.example.respond_to?(:exception)
       self.example.exception.nil?
     elsif !@test_passed.nil?
       @test_passed

data/nginx_test_helper.gemspec

@@ -18,6 +18,6 @@ Gem::Specification.new do |gem|
   gem.add_dependency "popen4"
 
   gem.add_development_dependency(%q<rspec>, [">= 2.10.0"])
-  gem.add_development_dependency(%q<debugger>, [">= 1.1.3"])
+  gem.add_development_dependency(%q<byebug>, [">= 3.5.1"])
   gem.add_development_dependency(%q<simplecov>, [">= 0.0.1"]) if RUBY_VERSION > "1.9.0"
 end

data/spec/nginx_test_helper/command_line_tool_spec.rb

@@ -3,8 +3,8 @@ require 'nginx_test_helper/command_line_tool'
 
 describe NginxTestHelper::CommandLineTool do
   before do
-    $stdout.stub(:puts)
-    Dir.stub(:pwd).and_return('tmp')
+    allow($stdout).to receive(:puts)
+    allow(Dir).to receive(:pwd).and_return('tmp')
     FileUtils.mkdir_p('tmp/spec')
   end
 
@@ -13,36 +13,36 @@ describe NginxTestHelper::CommandLineTool do
   end
 
   it "should list available options" do
-    $stdout.should_receive(:puts).with(/init/)
-    $stdout.should_receive(:puts).with(/license/)
+    expect($stdout).to receive(:puts).with(/init/)
+    expect($stdout).to receive(:puts).with(/license/)
     NginxTestHelper::CommandLineTool.new.process []
   end
 
   it "should list the gem license" do
-    $stdout.should_receive(:puts).with(/MIT License/)
+    expect($stdout).to receive(:puts).with(/MIT License/)
     NginxTestHelper::CommandLineTool.new.process ["license"]
   end
 
   it "should create example files showing how to use the gem" do
     NginxTestHelper::CommandLineTool.new.process ["init"]
-    File.exists?('tmp/spec/nginx_configuration.rb').should be_true
-    File.exists?('tmp/spec/example_spec.rb').should be_true
-    File.exists?('tmp/spec/spec_helper.rb').should be_true
+    expect(File.exists?('tmp/spec/nginx_configuration.rb')).to be true
+    expect(File.exists?('tmp/spec/example_spec.rb')).to be true
+    expect(File.exists?('tmp/spec/spec_helper.rb')).to be true
 
-    File.read('tmp/spec/nginx_configuration.rb').should eql(File.read('templates/spec/nginx_configuration.rb'))
-    File.read('tmp/spec/example_spec.rb').should eql(File.read('templates/spec/example_spec.rb'))
-    File.read('tmp/spec/spec_helper.rb').should include('nginx_configuration')
+    expect(File.read('tmp/spec/nginx_configuration.rb')).to eql(File.read('templates/spec/nginx_configuration.rb'))
+    expect(File.read('tmp/spec/example_spec.rb')).to eql(File.read('templates/spec/example_spec.rb'))
+    expect(File.read('tmp/spec/spec_helper.rb')).to include('nginx_configuration')
   end
 
   it "should include require call on spec_helper if NgincConfiguration is not defined" do
-    Object.stub(:const_defined?).with('NginxConfiguration').and_return(false)
+    allow(Object).to receive(:const_defined?).with('NginxConfiguration').and_return(false)
     File.open('tmp/spec/spec_helper.rb', 'w') { |f| f.write("#spec_helper content") }
     NginxTestHelper::CommandLineTool.new.process ["init"]
-    File.read('tmp/spec/spec_helper.rb').should eql("#spec_helper content\nrequire File.expand_path('nginx_configuration', File.dirname(__FILE__))")
+    expect(File.read('tmp/spec/spec_helper.rb')).to eql("#spec_helper content\nrequire File.expand_path('nginx_configuration', File.dirname(__FILE__))")
   end
 
   it "should print INSTALL file content" do
-    $stdout.should_receive(:puts).with(/Nginx Test Helper has been installed with example specs./)
+    expect($stdout).to receive(:puts).with(/Nginx Test Helper has been installed with example specs./)
     NginxTestHelper::CommandLineTool.new.process ["init"]
   end
 end

data/spec/nginx_test_helper/config_spec.rb

@@ -6,58 +6,58 @@ describe NginxTestHelper::Config do
   let(:subject) { NginxTestHelper::Config.new("config_id", configuration) }
 
   it "should include NginxTestHelper module" do
-    subject.class.included_modules.should include(NginxTestHelper::EnvMethods)
+    expect(subject.class.included_modules).to include(NginxTestHelper::EnvMethods)
   end
 
   it "should define some keys with configuration filename, logs and temp dirs configurations" do
     default_configuration = NginxTestHelper::Config.new("config_id", {}).configuration
-    default_configuration[:configuration_filename].should eql("/tmp/nginx_tests/config_id.conf")
-    default_configuration[:pid_file].should eql("/tmp/nginx_tests/nginx.pid")
-    default_configuration[:access_log].should eql("/tmp/nginx_tests/logs/access-config_id.log")
-    default_configuration[:error_log].should eql("/tmp/nginx_tests/logs/error-config_id.log")
-    default_configuration[:client_body_temp].should eql("/tmp/nginx_tests/client_body_temp")
+    expect(default_configuration[:configuration_filename]).to eql("/tmp/nginx_tests/config_id.conf")
+    expect(default_configuration[:pid_file]).to eql("/tmp/nginx_tests/nginx.pid")
+    expect(default_configuration[:access_log]).to eql("/tmp/nginx_tests/logs/access-config_id.log")
+    expect(default_configuration[:error_log]).to eql("/tmp/nginx_tests/logs/error-config_id.log")
+    expect(default_configuration[:client_body_temp]).to eql("/tmp/nginx_tests/client_body_temp")
   end
 
   it "should merge 'default configuration' with configuration filename, logs and temp dirs configurations" do
     default_configuration = NginxTestHelper::Config.new("config_id", {}).configuration
-    default_configuration.keys.should eql([:conf_item, :configuration_filename, :pid_file, :access_log, :error_log, :client_body_temp])
+    expect(default_configuration.keys).to eql([:conf_item, :configuration_filename, :pid_file, :access_log, :error_log, :client_body_temp])
   end
 
   it "should merge given configuration with 'default configuration', configuration filename, logs and temp dirs configurations" do
     default_configuration = NginxTestHelper::Config.new("config_id", {:custom_key => "value"}).configuration
-    default_configuration.keys.should eql([:conf_item, :custom_key, :configuration_filename, :pid_file, :access_log, :error_log, :client_body_temp])
+    expect(default_configuration.keys).to eql([:conf_item, :custom_key, :configuration_filename, :pid_file, :access_log, :error_log, :client_body_temp])
   end
 
   it "should create dirs where logs and client_body_temp will be stored" do
     NginxTestHelper::Config.new("config_id", {})
-    File.exists?("/tmp/nginx_tests/logs").should be_true
-    File.exists?("/tmp/nginx_tests/client_body_temp").should be_true
+    expect(File.exists?("/tmp/nginx_tests/logs")).to be true
+    expect(File.exists?("/tmp/nginx_tests/client_body_temp")).to be true
   end
 
   it "should create the configuration file using the template configuration" do
-    File.read(subject.configuration[:configuration_filename]).should eql('"template configuration config_id"')
+    expect(File.read(subject.configuration[:configuration_filename])).to eql('"template configuration config_id"')
   end
 
   context "when using an alternative template" do
     let(:configuration) { {:foo => "bar", :configuration_template => %("custom template writing <%=configuration[:foo]%>")} }
 
     it "should create the configuration file using this template" do
-      File.read(subject.configuration[:configuration_filename]).should eql('"custom template writing bar"')
+      expect(File.read(subject.configuration[:configuration_filename])).to eql('"custom template writing bar"')
     end
   end
 
   it "should has a method to delete config and log files" do
     NginxTestHelper::Config.delete_config_and_log_files(subject.config_id)
-    File.exists?(subject.configuration[:configuration_filename]).should be_false
-    File.exists?(subject.configuration[:access_log]).should be_false
-    File.exists?(subject.configuration[:error_log]).should be_false
-    File.exists?(subject.configuration[:client_body_temp]).should be_false
+    expect(File.exists?(subject.configuration[:configuration_filename])).to be false
+    expect(File.exists?(subject.configuration[:access_log])).to be false
+    expect(File.exists?(subject.configuration[:error_log])).to be false
+    expect(File.exists?(subject.configuration[:client_body_temp])).to be false
   end
 
   it "should expose configurations keys as methods" do
     config = NginxTestHelper::Config.new("config_id", { :foo => "bar", :xyz => 1})
-    config.foo.should eql("bar")
-    config.xyz.should eql(1)
+    expect(config.foo).to eql("bar")
+    expect(config.xyz).to eql(1)
   end
 
   it "should raise exception if configuration key does not exists" do
@@ -67,8 +67,8 @@ describe NginxTestHelper::Config do
 
   it "should return 'true' to respond_to method for a configuration key" do
     config = NginxTestHelper::Config.new("config_id", { :foo => "bar"})
-    config.should respond_to("config_id")
-    config.should respond_to(:foo)
+    expect(config).to respond_to("config_id")
+    expect(config).to respond_to(:foo)
   end
 
   context "when using the write_directive helper method" do
@@ -76,14 +76,14 @@ describe NginxTestHelper::Config do
 
     it "should comment the line when value is nil" do
       conf = File.read(subject.configuration[:configuration_filename])
-      conf.should include(%(\n#comment xyz\n#xyz "";))
-      conf.should include(%(\n#xyz_without_comment "";))
+      expect(conf).to include(%(\n#comment xyz\n#xyz "";))
+      expect(conf).to include(%(\n#xyz_without_comment "";))
     end
 
     it "should write the line when value is not nil" do
       conf = File.read(subject.configuration[:configuration_filename])
-      conf.should include(%(\n#comment foo\nname "bar";))
-      conf.should include(%(\nwithout_comment "bar";))
+      expect(conf).to include(%(\n#comment foo\nname "bar";))
+      expect(conf).to include(%(\nwithout_comment "bar";))
     end
 
     context "when value is an Array" do
@@ -91,8 +91,8 @@ describe NginxTestHelper::Config do
 
       it "should write multiple itens without quotes" do
         conf = File.read(subject.configuration[:configuration_filename])
-        conf.should include(%(\n#comment foo\nname bar zzz;))
-        conf.should include(%(\nwithout_comment bar zzz;))
+        expect(conf).to include(%(\n#comment foo\nname bar zzz;))
+        expect(conf).to include(%(\nwithout_comment bar zzz;))
       end
     end
   end

data/spec/nginx_test_helper/env_methods_spec.rb

@@ -8,82 +8,82 @@ describe NginxTestHelper::EnvMethods do
   shared_examples_for "has nginx configuration methods" do
     context "with default values" do
       it "should return nginx executable" do
-        subject.nginx_executable.should eql("/usr/local/nginx/sbin/nginx")
+        expect(subject.nginx_executable).to eql("/usr/local/nginx/sbin/nginx")
       end
 
       it "should return nginx host" do
-        subject.nginx_host.should eql("127.0.0.1")
+        expect(subject.nginx_host).to eql("127.0.0.1")
       end
 
       it "should return nginx port" do
-        subject.nginx_port.should eql("9990")
+        expect(subject.nginx_port).to eql("9990")
       end
 
       it "should return nginx workers" do
-        subject.nginx_workers.should eql("1")
+        expect(subject.nginx_workers).to eql("1")
       end
 
       it "should return nginx tests tmp dir" do
-        subject.nginx_tests_tmp_dir.should eql("/tmp/nginx_tests")
+        expect(subject.nginx_tests_tmp_dir).to eql("/tmp/nginx_tests")
       end
 
       it "should return nginx tests cores dir based on tmp dir" do
-        subject.nginx_tests_cores_dir.should eql("/tmp/nginx_tests/cores")
+        expect(subject.nginx_tests_cores_dir).to eql("/tmp/nginx_tests/cores")
       end
 
       it "should return nginx tests core dir based on tmp dir" do
-        subject.nginx_tests_core_dir("test_id").should eql("/tmp/nginx_tests/cores/test_id")
+        expect(subject.nginx_tests_core_dir("test_id")).to eql("/tmp/nginx_tests/cores/test_id")
       end
     end
 
     context "with environment values" do
       it "should return nginx executable" do
         ENV['NGINX_EXEC'] = "/path/to/nginx/executable"
-        subject.nginx_executable.should eql("/path/to/nginx/executable")
+        expect(subject.nginx_executable).to eql("/path/to/nginx/executable")
       end
 
       it "should return nginx host" do
         ENV['NGINX_HOST'] = "some_host"
-        subject.nginx_host.should eql("some_host")
+        expect(subject.nginx_host).to eql("some_host")
       end
 
       it "should return nginx port" do
       ENV['NGINX_PORT'] = "some_port"
-        subject.nginx_port.should eql("some_port")
+        expect(subject.nginx_port).to eql("some_port")
       end
 
       it "should return nginx workers" do
         ENV['NGINX_WORKERS'] = "25"
-        subject.nginx_workers.should eql("25")
+        expect(subject.nginx_workers).to eql("25")
       end
 
       it "should return nginx tests tmp dir" do
         ENV['NGINX_TESTS_TMP_DIR'] = "/path/to/tests/tmp/dir"
-        subject.nginx_tests_tmp_dir.should eql("/path/to/tests/tmp/dir")
+        expect(subject.nginx_tests_tmp_dir).to eql("/path/to/tests/tmp/dir")
       end
 
       it "should return nginx tests cores dir based on tmp dir" do
         ENV['NGINX_TESTS_TMP_DIR'] = "/path/to/tests/tmp/dir"
-        subject.nginx_tests_cores_dir.should eql("/path/to/tests/tmp/dir/cores")
+        expect(subject.nginx_tests_cores_dir).to eql("/path/to/tests/tmp/dir/cores")
       end
 
       it "should return nginx tests core dir based on tmp dir" do
         ENV['NGINX_TESTS_TMP_DIR'] = "/path/to/tests/tmp/dir"
-        subject.nginx_tests_core_dir("test_id").should eql("/path/to/tests/tmp/dir/cores/test_id")
+        expect(subject.nginx_tests_core_dir("test_id")).to eql("/path/to/tests/tmp/dir/cores/test_id")
       end
     end
 
     it "should use nginx host and port to compose nginx address" do
-      subject.stub(:nginx_host).and_return("some_host")
-      subject.stub(:nginx_port).and_return("some_port")
+      allow(subject).to receive(:nginx_host).and_return("some_host")
+      allow(subject).to receive(:nginx_port).and_return("some_port")
 
-      subject.nginx_address.should eql("http://some_host:some_port")
+      expect(subject.nginx_address).to eql("http://some_host:some_port")
     end
 
     context "when on a Darwin ruby platform" do
       it "should return kqueue as event type" do
         with_constants({"RUBY_PLATFORM" => "x86_64-darwin13.0"}) do
-          subject.nginx_event_type.should eql("kqueue")
+          expect(subject.nginx_event_type).to eql("kqueue")
         end
       end
     end
@@ -91,7 +91,7 @@ describe NginxTestHelper::EnvMethods do
     context "when not on a Darwin ruby platform" do
       it "should return epoll as event type" do
         with_constants({"RUBY_PLATFORM" => "Any other platform"}) do
-          subject.nginx_event_type.should eql("epoll")
+          expect(subject.nginx_event_type).to eql("epoll")
         end
       end
     end

data/spec/nginx_test_helper/rspec_utils_spec.rb

@@ -4,92 +4,92 @@ require 'nginx_test_helper/rspec_utils'
 describe "rspec_utils" do
 
   it "should include NginxTestHelper module on RSpec tests" do
-    self.class.included_modules.should include(NginxTestHelper)
+    expect(self.class.included_modules).to include(NginxTestHelper)
   end
 
   context "when defining the 'be_in_the_interval' matcher" do
     context "and checking if the number is in the interval" do
       it "should be true when the actual value is equal to lower bound" do
-        expect { 10.should be_in_the_interval(10,12) }.to_not raise_error
+        expect { expect(10).to be_in_the_interval(10,12) }.to_not raise_error
       end
 
       it "should be true when the actual value is equal to upper bound" do
-        expect { 12.should be_in_the_interval(10,12) }.to_not raise_error
+        expect { expect(12).to be_in_the_interval(10,12) }.to_not raise_error
       end
 
       it "should be true when the actual value is between lower and upper bounds" do
-        expect { 11.should be_in_the_interval(10,12) }.to_not raise_error
+        expect { expect(11).to be_in_the_interval(10,12) }.to_not raise_error
       end
 
       it "should be false when the actual value is smaller than lower bound" do
-        expect { 9.should be_in_the_interval(10,12) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 9 would be in the interval from 10 to 12")
+        expect { expect(9).to be_in_the_interval(10,12) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 9 would be in the interval from 10 to 12")
       end
 
       it "should be false when the actual value is greater than upper bound" do
-        expect { 13.should be_in_the_interval(10,12) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 13 would be in the interval from 10 to 12")
+        expect { expect(13).to be_in_the_interval(10,12) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 13 would be in the interval from 10 to 12")
       end
 
       it "should accept float numbers" do
-        expect { 10.4.should be_in_the_interval(10.3,12.5) }.to_not raise_error
-        expect { 12.4.should be_in_the_interval(10.3,12.5) }.to_not raise_error
+        expect { expect(10.4).to be_in_the_interval(10.3,12.5) }.to_not raise_error
+        expect { expect(12.4).to be_in_the_interval(10.3,12.5) }.to_not raise_error
       end
     end
 
     context "and checking if the number is out the interval" do
       it "should be false when the actual value is equal to lower bound" do
-        expect { 10.should_not be_in_the_interval(10,12) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 10 would not be in the interval from 10 to 12")
+        expect { expect(10).not_to be_in_the_interval(10,12) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 10 would not be in the interval from 10 to 12")
       end
 
       it "should be false when the actual value is equal to upper bound" do
-        expect { 12.should_not be_in_the_interval(10,12) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 12 would not be in the interval from 10 to 12")
+        expect { expect(12).not_to be_in_the_interval(10,12) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 12 would not be in the interval from 10 to 12")
       end
 
       it "should be false when the actual value is between lower and upper bounds" do
-        expect { 11.should_not be_in_the_interval(10,12) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 11 would not be in the interval from 10 to 12")
+        expect { expect(11).not_to be_in_the_interval(10,12) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 11 would not be in the interval from 10 to 12")
       end
 
       it "should be true when the actual value is smaller than lower bound" do
-        expect { 9.should_not be_in_the_interval(10,12) }.to_not raise_error
+        expect { expect(9).not_to be_in_the_interval(10,12) }.to_not raise_error
       end
 
       it "should be true when the actual value is greater than upper bound" do
-        expect { 13.should_not be_in_the_interval(10,12) }.to_not raise_error
+        expect { expect(13).not_to be_in_the_interval(10,12) }.to_not raise_error
       end
 
       it "should accept float numbers" do
-        expect { 10.2.should_not be_in_the_interval(10.3,12.5) }.to_not raise_error
-        expect { 12.6.should_not be_in_the_interval(10.3,12.5) }.to_not raise_error
+        expect { expect(10.2).not_to be_in_the_interval(10.3,12.5) }.to_not raise_error
+        expect { expect(12.6).not_to be_in_the_interval(10.3,12.5) }.to_not raise_error
       end
     end
 
     it "should has a friendly description" do
-      be_in_the_interval(10.3,12.5).description.should eql("be in the interval from 10.3 to 12.5")
+      expect(be_in_the_interval(10.3,12.5).description).to eql("be in the interval from 10.3 to 12.5")
     end
   end
 
   context "when defining the 'match_the_pattern' matcher" do
     context "and checking if the text match the pattern" do
       it "should be true when the actual value match the expression" do
-        expect { "some text".should match_the_pattern(/EX/i) }.to_not raise_error
+        expect { expect("some text").to match_the_pattern(/EX/i) }.to_not raise_error
       end
 
       it "should be false when the actual value does not match the expression" do
-        expect { "some text".should match_the_pattern(/EX/) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 'some text' would match the pattern '/EX/'")
+        expect { expect("some text").to match_the_pattern(/EX/) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 'some text' would match the pattern '/EX/'")
       end
     end
 
     context "and checking if the text not match the pattern" do
       it "should be true when the actual value match the expression" do
-        expect { "some text".should_not match_the_pattern(/EX/i) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 'some text' would not match the pattern '/EX/i'")
+        expect { expect("some text").not_to match_the_pattern(/EX/i) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "expected that 'some text' would not match the pattern '/EX/i'")
       end
 
       it "should be false when the actual value does not match the expression" do
-        expect { "some text".should_not match_the_pattern(/EX/) }.to_not raise_error
+        expect { expect("some text").not_to match_the_pattern(/EX/) }.to_not raise_error
       end
     end
 
     it "should has a friendly description" do
-      match_the_pattern(/EX/i).description.should eql("match the pattern '/EX/i'")
+      expect(match_the_pattern(/EX/i).description).to eql("match the pattern '/EX/i'")
     end
   end
 end

data/spec/nginx_test_helper_spec.rb

@@ -6,92 +6,92 @@ describe NginxTestHelper do
   subject { Object.new.extend(NginxTestHelper) }
 
   it "should define a method with basic headers" do
-    subject.headers.should eql({'accept' => 'text/html'})
+    expect(subject.headers).to eql({'accept' => 'text/html'})
   end
 
   it "should define a method to calculate the difference in seconds of two dates" do
-    subject.time_diff_sec(Time.now, Time.now + 10).should eql(10)
+    expect(subject.time_diff_sec(Time.now, Time.now + 10)).to eql(10)
   end
 
   it "should define a method to calculate the difference in milliseconds of two dates" do
-    subject.time_diff_milli(Time.now, Time.now + 10).should eql(10000)
+    expect(subject.time_diff_milli(Time.now, Time.now + 10)).to eql(10000)
   end
 
   context "when working with sockets" do
     let(:socket) { SocketMock.new }
 
     it "should be possible to open a socket to a host and port" do
-      TCPSocket.should_receive(:open).with("xpto.com", 100).and_return(socket)
+      expect(TCPSocket).to receive(:open).with("xpto.com", 100).and_return(socket)
 
-      subject.open_socket("xpto.com", 100).should eql(socket)
+      expect(subject.open_socket("xpto.com", 100)).to eql(socket)
     end
 
     it "should be possible to do a GET in an url using the opened socket, and receive header and body response" do
-      socket.should_receive(:print).with("GET /index.html HTTP/1.1\r\nHost: localhost\r\n\r\n")
+      expect(socket).to receive(:print).with("GET /index.html HTTP/1.1\r\nHost: localhost\r\n\r\n")
 
       headers, body = subject.get_in_socket("/index.html", socket)
-      headers.should eql("HTTP 200 OK")
-      body.should eql("BODY")
+      expect(headers).to eql("HTTP 200 OK")
+      expect(body).to eql("BODY")
     end
 
     it "should be possible specify the host header value to do a GET" do
-      socket.should_receive(:print).with("GET /index.html HTTP/1.1\r\nHost: some_host_value\r\n\r\n")
+      expect(socket).to receive(:print).with("GET /index.html HTTP/1.1\r\nHost: some_host_value\r\n\r\n")
 
       headers, body = subject.get_in_socket("/index.html", socket, {:host_header => "some_host_value"})
-      headers.should eql("HTTP 200 OK")
-      body.should eql("BODY")
+      expect(headers).to eql("HTTP 200 OK")
+      expect(body).to eql("BODY")
     end
 
     it "should be possible use http 1.0 to do a GET" do
-      socket.should_receive(:print).with("GET /index.html HTTP/1.0\r\n\r\n")
+      expect(socket).to receive(:print).with("GET /index.html HTTP/1.0\r\n\r\n")
 
       headers, body = subject.get_in_socket("/index.html", socket, {:use_http_1_0 => true})
-      headers.should eql("HTTP 200 OK")
-      body.should eql("BODY")
+      expect(headers).to eql("HTTP 200 OK")
+      expect(body).to eql("BODY")
     end
 
     it "should pass 'wait_for' attribute to 'read_response_on_socket' method when doing a GET in a url" do
-      socket.should_receive(:print).with("GET /index.html HTTP/1.1\r\nHost: localhost\r\n\r\n")
-      subject.should_receive(:read_response_on_socket).with(socket, "wait for")
+      expect(socket).to receive(:print).with("GET /index.html HTTP/1.1\r\nHost: localhost\r\n\r\n")
+      expect(subject).to receive(:read_response_on_socket).with(socket, "wait for")
 
       subject.get_in_socket("/index.html", socket, {:wait_for => "wait for"})
     end
 
     it "should be possible to do a POST in an url using the opened socket, and receive header and body response" do
-      socket.should_receive(:print).with("POST /service HTTP/1.1\r\nHost: localhost\r\nContent-Length: 4\r\n\r\nBODY")
+      expect(socket).to receive(:print).with("POST /service HTTP/1.1\r\nHost: localhost\r\nContent-Length: 4\r\n\r\nBODY")
 
       headers, body = subject.post_in_socket("/service", "BODY", socket)
-      headers.should eql("HTTP 200 OK")
-      body.should eql("BODY")
+      expect(headers).to eql("HTTP 200 OK")
+      expect(body).to eql("BODY")
     end
 
     it "should be possible specify the host header value to do a POST" do
-      socket.should_receive(:print).with("POST /service HTTP/1.1\r\nHost: some_host_value\r\nContent-Length: 4\r\n\r\nBODY")
+      expect(socket).to receive(:print).with("POST /service HTTP/1.1\r\nHost: some_host_value\r\nContent-Length: 4\r\n\r\nBODY")
 
       headers, body = subject.post_in_socket("/service", "BODY", socket, {:host_header => "some_host_value"})
-      headers.should eql("HTTP 200 OK")
-      body.should eql("BODY")
+      expect(headers).to eql("HTTP 200 OK")
+      expect(body).to eql("BODY")
     end
 
     it "should be possible use http 1.0 to do a POST" do
-      socket.should_receive(:print).with("POST /service HTTP/1.0\r\nContent-Length: 4\r\n\r\nBODY")
+      expect(socket).to receive(:print).with("POST /service HTTP/1.0\r\nContent-Length: 4\r\n\r\nBODY")
 
       headers, body = subject.post_in_socket("/service", "BODY", socket, {:use_http_1_0 => true})
-      headers.should eql("HTTP 200 OK")
-      body.should eql("BODY")
+      expect(headers).to eql("HTTP 200 OK")
+      expect(body).to eql("BODY")
     end
 
     it "should pass 'wait_for' attribute to 'read_response_on_socket' method when doing a POST in a url" do
-      socket.should_receive(:print).with("POST /service HTTP/1.1\r\nHost: localhost\r\nContent-Length: 4\r\n\r\nBODY")
-      subject.should_receive(:read_response_on_socket).with(socket, "wait for")
+      expect(socket).to receive(:print).with("POST /service HTTP/1.1\r\nHost: localhost\r\nContent-Length: 4\r\n\r\nBODY")
+      expect(subject).to receive(:read_response_on_socket).with(socket, "wait for")
 
       headers, body = subject.post_in_socket("/service", "BODY", socket, {:wait_for => "wait for"})
     end
 
     it "should be possible read a response in a opened socket" do
       headers, body = subject.read_response_on_socket(socket)
-      headers.should eql("HTTP 200 OK")
-      body.should eql("BODY")
+      expect(headers).to eql("HTTP 200 OK")
+      expect(body).to eql("BODY")
     end
 
     it "should concatenate response parts" do
@@ -99,12 +99,12 @@ describe NginxTestHelper do
       socket.response2 = "Y"
 
       headers, body = subject.read_response_on_socket(socket)
-      headers.should eql("HTTP 200 OK")
-      body.should eql("BODYXY")
+      expect(headers).to eql("HTTP 200 OK")
+      expect(body).to eql("BODYXY")
     end
 
     it "should raise error if not receive a response" do
-      socket.stub(:readpartial).and_raise(Exception)
+      allow(socket).to receive(:readpartial).and_raise(Exception)
 
       expect { subject.read_response_on_socket(socket) }.to raise_error("Any response")
     end
@@ -117,8 +117,8 @@ describe NginxTestHelper do
           socket.exception = Errno::EAGAIN
 
           headers, body = subject.read_response_on_socket(socket)
-          headers.should eql("HTTP 200 OK")
-          body.should eql("BODYX")
+          expect(headers).to eql("HTTP 200 OK")
+          expect(body).to eql("BODYX")
         end
       end
 
@@ -127,19 +127,19 @@ describe NginxTestHelper do
           socket.exception = Errno::EAGAIN
 
           headers, body = subject.read_response_on_socket(socket, "OD")
-          headers.should eql("HTTP 200 OK")
-          body.should eql("BODY")
+          expect(headers).to eql("HTTP 200 OK")
+          expect(body).to eql("BODY")
         end
 
         it "should retry if the text is not present in the response" do
           socket.exception = Errno::EAGAIN
           socket.response3 = "Z"
 
-          IO.should_receive(:select).with([socket])
+          expect(IO).to receive(:select).with([socket])
 
           headers, body = subject.read_response_on_socket(socket, "Z")
-          headers.should eql("HTTP 200 OK")
-          body.should include("BODY")
+          expect(headers).to eql("HTTP 200 OK")
+          expect(body).to include("BODY")
         end
       end
     end
@@ -147,64 +147,64 @@ describe NginxTestHelper do
 
   context "when testing configuration" do
     before do
-      subject.stub(:config_id).and_return("config_id")
-      subject.stub(:start_server).and_return("Server started")
-      subject.stub(:stop_server).and_return("Server stoped")
+      allow(subject).to receive(:config_id).and_return("config_id")
+      allow(subject).to receive(:start_server).and_return("Server started")
+      allow(subject).to receive(:stop_server).and_return("Server stoped")
     end
 
     it "should create an instance of NginxTestHelper::Config with the given configuation" do
       config = NginxTestHelper::Config.new("config_id", {:foo => "bar"})
-      NginxTestHelper::Config.should_receive(:new).with("config_id", {:foo => "bar"}).and_return(config)
+      expect(NginxTestHelper::Config).to receive(:new).with("config_id", {:foo => "bar"}).and_return(config)
       subject.nginx_test_configuration({:foo => "bar"})
     end
 
     it "should accept test default configuration" do
       config = NginxTestHelper::Config.new("config_id", {})
-      NginxTestHelper::Config.should_receive(:new).with("config_id", {}).and_return(config)
+      expect(NginxTestHelper::Config).to receive(:new).with("config_id", {}).and_return(config)
       subject.nginx_test_configuration
     end
 
     it "should call start_server and stop_server methods" do
-      subject.should_receive(:start_server).and_return("Server started")
-      subject.should_receive(:stop_server).and_return("Server stoped")
+      expect(subject).to receive(:start_server).and_return("Server started")
+      expect(subject).to receive(:stop_server).and_return("Server stoped")
       subject.nginx_test_configuration({:foo => "bar"})
     end
 
     it "should return start command result" do
-      subject.nginx_test_configuration({:foo => "bar"}).should eql("Server started\n")
+      expect(subject.nginx_test_configuration({:foo => "bar"})).to eql("Server started\n")
     end
 
     it "should return start command result concatenated with error log content if exists" do
       FileUtils.mkdir_p("/tmp/nginx_tests/logs/")
       File.open("/tmp/nginx_tests/logs/error-config_id.log", "w") { |f| f.write("Error log content") }
-      subject.nginx_test_configuration({:foo => "bar"}).should eql("Server started\nError log content")
+      expect(subject.nginx_test_configuration({:foo => "bar"})).to eql("Server started\nError log content")
     end
   end
 
   context "when starting server to make tests" do
     before do
-      subject.stub(:config_id).and_return("config_id")
-      subject.stub(:start_server).and_return("Server started")
-      subject.stub(:stop_server).and_return("Server stoped")
+      allow(subject).to receive(:config_id).and_return("config_id")
+      allow(subject).to receive(:start_server).and_return("Server started")
+      allow(subject).to receive(:stop_server).and_return("Server stoped")
     end
 
     it "should create an instance of NginxTestHelper::Config with the given configuation" do
       config = NginxTestHelper::Config.new("config_id", {:foo => "bar"})
-      NginxTestHelper::Config.should_receive(:new).with("config_id", {:foo => "bar"}).and_return(config)
+      expect(NginxTestHelper::Config).to receive(:new).with("config_id", {:foo => "bar"}).and_return(config)
       subject.nginx_run_server({:foo => "bar"}) {}
     end
 
     it "should accept test default configuration" do
       config = NginxTestHelper::Config.new("config_id", {})
-      NginxTestHelper::Config.should_receive(:new).with("config_id", {}).and_return(config)
+      expect(NginxTestHelper::Config).to receive(:new).with("config_id", {}).and_return(config)
       subject.nginx_run_server {}
     end
 
     it "should execute the block after start_server and before stop_server methods" do
       obj = {:xyz => 1}
-      subject.should_receive(:start_server).ordered
-      obj.should_receive(:delete).with(:xyz).ordered
-      subject.should_receive(:stop_server).ordered
+      expect(subject).to receive(:start_server).ordered
+      expect(obj).to receive(:delete).with(:xyz).ordered
+      expect(subject).to receive(:stop_server).ordered
 
       subject.nginx_run_server({:foo => "bar"}) { obj.delete(:xyz) }
     end
@@ -219,78 +219,81 @@ describe NginxTestHelper do
     end
 
     it "should execute stop_server method if an exception was raised" do
-      subject.should_receive(:stop_server)
+      expect(subject).to receive(:stop_server)
       expect { subject.nginx_run_server({:foo => "bar"}) { raise "some error" } }.to raise_error("some error")
     end
   end
 
   context "when checking internal behavior" do
     before do
-      subject.stub(:start_server).and_return("Server started")
-      subject.stub(:stop_server).and_return("Server stoped")
-      subject.stub(:example).and_return(double)
+      allow(subject).to receive(:start_server).and_return("Server started")
+      allow(subject).to receive(:stop_server).and_return("Server stoped")
+      allow(subject).to receive(:example).and_return(double)
     end
 
     context "and check config_id value" do
+      before { Thread.current[:current_example] = nil }
+      after { |ex| Thread.current[:current_example] = ex }
+
       it "should use example metadata if available" do
-        subject.example.stub(:metadata).and_return(:location => "./spec/test_config_id_spec.rb:100")
-        subject.send(:config_id).should eql("test_config_id_spec_rb_100")
+        allow(subject.example).to receive(:metadata).and_return(:location => "./spec/test_config_id_spec.rb:100")
+        expect(subject.send(:config_id)).to eql("test_config_id_spec_rb_100")
       end
 
       it "should use method_name if example metadata is not available" do
-        subject.example.stub(:metadata).and_return(nil)
-        subject.stub(:method_name).and_return("test_config_id_by_method_name")
+        allow(subject.example).to receive(:metadata).and_return(nil)
+        allow(subject).to receive(:method_name).and_return("test_config_id_by_method_name")
 
-        subject.send(:config_id).should eql("test_config_id_by_method_name")
+        expect(subject.send(:config_id)).to eql("test_config_id_by_method_name")
       end
 
       it "should use __name__ if example metadata and method_name are not available" do
-        subject.example.stub(:metadata).and_return(nil)
-        subject.stub(:__name__).and_return("test_config_id_by___name__")
+        allow(subject.example).to receive(:metadata).and_return(nil)
+        allow(subject).to receive(:__name__).and_return("test_config_id_by___name__")
 
-        subject.send(:config_id).should eql("test_config_id_by___name__")
+        expect(subject.send(:config_id)).to eql("test_config_id_by___name__")
       end
     end
 
     context "and check if the test has passed" do
       context "using example exception if available" do
         it "should be 'true' if exception is 'nil'" do
-          subject.example.stub(:exception).and_return(nil)
-          subject.send(:has_passed?).should be_true
+          allow(subject.example).to receive(:exception).and_return(nil)
+          expect(subject.send(:has_passed?)).to be true
         end
 
         it "should be 'false' if exception is not 'nil'" do
-          subject.example.stub(:exception).and_return("")
-          subject.send(:has_passed?).should be_false
+          allow(subject.example).to receive(:exception).and_return("")
+          expect(subject.send(:has_passed?)).to be false
         end
       end
 
       context "using 'test_passed' attribute if example exception is not available" do
         it "should be 'true' if 'test_passed' is 'true'" do
           subject.instance_variable_set(:@test_passed, true)
-          subject.send(:has_passed?).should be_true
+          expect(subject.send(:has_passed?)).to be true
         end
 
         it "should be 'false' if 'test_passed' is 'false'" do
           subject.instance_variable_set(:@test_passed, false)
-          subject.send(:has_passed?).should be_false
+          expect(subject.send(:has_passed?)).to be false
         end
       end
 
       context "using 'passed' attribute if example exception and 'test_passed' are not available" do
         before do
-          subject.example.stub(:instance_variable_defined?).with(:@exception).and_return(false)
+          allow(subject.example).to receive(:instance_variable_defined?).with(:@exception).and_return(false)
           subject.instance_variable_set(:@test_passed, nil)
         end
 
         it "should be 'true' if 'passed' is 'true'" do
           subject.instance_variable_set(:@passed, true)
-          subject.send(:has_passed?).should be_true
+          expect(subject.send(:has_passed?)).to be true
         end
 
         it "should be 'false' if 'passed' is 'false'" do
           subject.instance_variable_set(:@passed, false)
-          subject.send(:has_passed?).should be_false
+          expect(subject.send(:has_passed?)).to be false
         end
       end
     end
@@ -301,24 +304,24 @@ describe NginxTestHelper do
     let(:status) { Status.new }
 
     it "should use POpen4 to execute the command" do
-      POpen4.should_receive(:popen4).with("/usr/local/nginx/sbin/nginx -c /tmp/nginx_tests/config_id.conf").and_return(status)
+      expect(POpen4).to receive(:popen4).with("/usr/local/nginx/sbin/nginx -c /tmp/nginx_tests/config_id.conf").and_return(status)
       subject.start_server(config)
     end
 
     it "should not start the server if configuration has a key 'disable_start_stop_server' with 'true'" do
       config.configuration[:disable_start_stop_server] = true
-      POpen4.should_not_receive(:popen4)
+      expect(POpen4).not_to receive(:popen4)
       subject.start_server(config)
     end
 
     it "should raise error if 'exitstatus' is not '0'" do
       status.exitstatus = 1
-      POpen4.should_receive(:popen4).with("/usr/local/nginx/sbin/nginx -c /tmp/nginx_tests/config_id.conf").and_return(status)
+      expect(POpen4).to receive(:popen4).with("/usr/local/nginx/sbin/nginx -c /tmp/nginx_tests/config_id.conf").and_return(status)
       expect { subject.start_server(config) }.to raise_error("Server doesn't started - ")
     end
 
     it "should return error message when the command fail" do
-      subject.start_server(config).should eql("nginx: [emerg] unexpected end of file, expecting \";\" or \"}\" in /tmp/nginx_tests/config_id.conf:1")
+      expect(subject.start_server(config)).to eql("nginx: [emerg] unexpected end of file, expecting \";\" or \"}\" in /tmp/nginx_tests/config_id.conf:1")
     end
   end
 
@@ -327,24 +330,24 @@ describe NginxTestHelper do
     let(:status) { Status.new }
 
     it "should use POpen4 to execute the command" do
-      POpen4.should_receive(:popen4).with("/usr/local/nginx/sbin/nginx -c /tmp/nginx_tests/config_id.conf -s stop").and_return(status)
+      expect(POpen4).to receive(:popen4).with("/usr/local/nginx/sbin/nginx -c /tmp/nginx_tests/config_id.conf -s stop").and_return(status)
       subject.stop_server(config)
     end
 
     it "should not start the server if configuration has a key 'disable_start_stop_server' with 'true'" do
       config.configuration[:disable_start_stop_server] = true
-      POpen4.should_not_receive(:popen4)
+      expect(POpen4).not_to receive(:popen4)
       subject.stop_server(config)
     end
 
     it "should raise error if 'exitstatus' is not '0'" do
       status.exitstatus = 1
-      POpen4.should_receive(:popen4).with("/usr/local/nginx/sbin/nginx -c /tmp/nginx_tests/config_id.conf -s stop").and_return(status)
+      expect(POpen4).to receive(:popen4).with("/usr/local/nginx/sbin/nginx -c /tmp/nginx_tests/config_id.conf -s stop").and_return(status)
       expect { subject.stop_server(config) }.to raise_error("Server doesn't stoped - ")
     end
 
     it "should return error message when the command fail" do
-      subject.stop_server(config).should eql("nginx: [emerg] unexpected end of file, expecting \";\" or \"}\" in /tmp/nginx_tests/config_id.conf:1")
+      expect(subject.stop_server(config)).to eql("nginx: [emerg] unexpected end of file, expecting \";\" or \"}\" in /tmp/nginx_tests/config_id.conf:1")
     end
   end
 

data/spec/spec_helper.rb

@@ -5,7 +5,7 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.treat_symbols_as_metadata_keys_with_true_values = true if RSpec::Core::Version::STRING < "3.0.0"
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: nginx_test_helper
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Wandenberg Peixoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-26 00:00:00.000000000 Z
+date: 2015-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: popen4
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.10.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.10.0
 - !ruby/object:Gem::Dependency
-  name: debugger
+  name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.3
+        version: 3.5.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.3
+        version: 3.5.1
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.1
 description: A collection of helper methods to test your nginx module.
@@ -74,8 +74,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
+- ".gitignore"
+- ".rspec"
 - Gemfile
 - LICENSE
 - README.md
@@ -108,12 +108,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []