nginx_test_helper 0.2.0 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 75c520d4f170c613f24605612e69088fedb3a219
+  data.tar.gz: a7c16004fb9a1a01a89ff5d331fef4376978c689
+SHA512:
+  metadata.gz: 706b0d4e95fbfae35443faad3f6916e223e2a8074c2e866fa336689d4c1a7d1231d1d1f3d6662902e8b2d8297c94fc4c2b45f86c57c137ea993ada8f8f89d59f
+  data.tar.gz: 9a843a5c7cb60820a533db67dc3e226d37039d045e19c7ef4ee88bb97b364ee9a15ad2398c632a7ce925832ca30e66774ff8c5d6a36fac0b8d10bb5c07a2c11d

data/lib/nginx_test_helper/rspec_utils.rb

@@ -1,4 +1,6 @@
 if defined?(RSpec)
+  require 'nginx_test_helper/http_matchers'
+
   RSpec.configure do |config|
     config.include NginxTestHelper
     config.include NginxTestHelper::HttpMatchers

data/lib/nginx_test_helper/version.rb

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

data/lib/nginx_test_helper.rb

@@ -45,20 +45,23 @@ module NginxTestHelper
   end
 
   def read_response_on_socket(socket, wait_for=nil)
+    will_retry = false
     response ||= socket.readpartial(1)
     while (tmp = socket.read_nonblock(256))
       response += tmp
     end
   rescue Errno::EAGAIN => e
-    headers, body = (response || "").split("\r\n\r\n", 2)
-    if !wait_for.nil? && (body.nil? || body.empty? || !body.include?(wait_for))
+    unless(wait_for.nil? || response.include?(wait_for))
+      will_retry = true
       IO.select([socket])
       retry
     end
   ensure
-    fail("Any response") if response.nil?
-    headers, body = response.split("\r\n\r\n", 2)
-    return headers, body
+    unless will_retry
+      fail("Any response") if response.nil?
+      headers, body = response.split("\r\n\r\n", 2)
+      return headers, body
+    end
   end
 
   def time_diff_milli(start, finish)
@@ -76,14 +79,14 @@ module NginxTestHelper
   def start_server(config)
     error_message = ""
     unless config.configuration[:disable_start_stop_server]
-      working_dir = nginx_tests_core_dir(config_id)
+      working_dir = nginx_tests_core_dir(config.config_id)
       FileUtils.mkdir_p working_dir
       Dir.chdir working_dir do
         status = POpen4::popen4("#{ config.nginx_executable } -c #{ config.configuration_filename }") do |stdout, stderr, stdin, pid|
           error_message = stderr.read.strip unless stderr.eof
           return error_message unless error_message.nil?
         end
-        fail("Server doesn't started - #{error_message}") unless status.exitstatus == 0
+        fail("Server doesn't started - #{error_message}") if (status.nil? || status.exitstatus != 0)
       end
     end
     error_message
@@ -96,7 +99,7 @@ module NginxTestHelper
         error_message = stderr.read.strip unless stderr.eof
         return error_message unless error_message.nil?
       end
-      fail("Server doesn't stoped - #{error_message}") unless status.exitstatus == 0
+      fail("Server doesn't stoped - #{error_message}") if (status.nil? || status.exitstatus != 0)
     end
     error_message
   end
@@ -115,7 +118,7 @@ private
   end
 
   def has_passed?
-    if self.respond_to?(:example) && !self.example.nil? && self.example.instance_variable_defined?(:@exception)
+    if self.respond_to?(:example) && !self.example.nil? && self.example.respond_to?(:exception)
       self.example.exception.nil?
     elsif !@test_passed.nil?
       @test_passed

data/spec/nginx_test_helper/command_line_tool_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
+require 'nginx_test_helper/command_line_tool'
 
 describe NginxTestHelper::CommandLineTool do
   before do
-    $stdout.stub!(:puts)
-    Dir.stub!(:pwd).and_return('tmp')
+    $stdout.stub(:puts)
+    Dir.stub(:pwd).and_return('tmp')
     FileUtils.mkdir_p('tmp/spec')
   end
 
@@ -34,7 +35,7 @@ describe NginxTestHelper::CommandLineTool do
   end
 
   it "should include require call on spec_helper if NgincConfiguration is not defined" do
-    Object.stub!(:const_defined?).with('NginxConfiguration').and_return(false)
+    Object.stub(: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__))")

data/spec/nginx_test_helper/config_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'nginx_test_helper/config'
 
 describe NginxTestHelper::Config do
   let(:configuration) { {} }

data/spec/nginx_test_helper/rspec_utils_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'nginx_test_helper/rspec_utils'
 
 describe "rspec_utils" do
 

data/spec/nginx_test_helper_spec.rb

@@ -1,18 +1,20 @@
 require 'spec_helper'
+require 'nginx_test_helper'
 
 describe NginxTestHelper do
-  include NginxTestHelper
+
+  subject { Object.new.extend(NginxTestHelper) }
 
   it "should define a method with basic headers" do
-    headers.should eql({'accept' => 'text/html'})
+    subject.headers.should eql({'accept' => 'text/html'})
   end
 
   it "should define a method to calculate the difference in seconds of two dates" do
-    time_diff_sec(Time.now, Time.now + 10).should eql(10)
+    subject.time_diff_sec(Time.now, Time.now + 10).should eql(10)
   end
 
   it "should define a method to calculate the difference in milliseconds of two dates" do
-    time_diff_milli(Time.now, Time.now + 10).should eql(10000)
+    subject.time_diff_milli(Time.now, Time.now + 10).should eql(10000)
   end
 
   context "when working with sockets" do
@@ -21,13 +23,13 @@ describe NginxTestHelper do
     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)
 
-      open_socket("xpto.com", 100).should eql(socket)
+      subject.open_socket("xpto.com", 100).should 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")
 
-      headers, body = get_in_socket("/index.html", socket)
+      headers, body = subject.get_in_socket("/index.html", socket)
       headers.should eql("HTTP 200 OK")
       body.should eql("BODY")
     end
@@ -35,7 +37,7 @@ describe NginxTestHelper do
     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")
 
-      headers, body = get_in_socket("/index.html", socket, {:host_header => "some_host_value"})
+      headers, body = subject.get_in_socket("/index.html", socket, {:host_header => "some_host_value"})
       headers.should eql("HTTP 200 OK")
       body.should eql("BODY")
     end
@@ -43,22 +45,22 @@ describe NginxTestHelper do
     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")
 
-      headers, body = get_in_socket("/index.html", socket, {:use_http_1_0 => true})
+      headers, body = subject.get_in_socket("/index.html", socket, {:use_http_1_0 => true})
       headers.should eql("HTTP 200 OK")
       body.should 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")
-      self.should_receive(:read_response_on_socket).with(socket, "wait for")
+      subject.should_receive(:read_response_on_socket).with(socket, "wait for")
 
-      get_in_socket("/index.html", socket, {:wait_for => "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")
 
-      headers, body = post_in_socket("/service", "BODY", socket)
+      headers, body = subject.post_in_socket("/service", "BODY", socket)
       headers.should eql("HTTP 200 OK")
       body.should eql("BODY")
     end
@@ -66,7 +68,7 @@ describe NginxTestHelper do
     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")
 
-      headers, body = post_in_socket("/service", "BODY", socket, {:host_header => "some_host_value"})
+      headers, body = subject.post_in_socket("/service", "BODY", socket, {:host_header => "some_host_value"})
       headers.should eql("HTTP 200 OK")
       body.should eql("BODY")
     end
@@ -74,20 +76,20 @@ describe NginxTestHelper do
     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")
 
-      headers, body = post_in_socket("/service", "BODY", socket, {:use_http_1_0 => true})
+      headers, body = subject.post_in_socket("/service", "BODY", socket, {:use_http_1_0 => true})
       headers.should eql("HTTP 200 OK")
       body.should 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")
-      self.should_receive(:read_response_on_socket).with(socket, "wait for")
+      subject.should_receive(:read_response_on_socket).with(socket, "wait for")
 
-      headers, body = post_in_socket("/service", "BODY", socket, {:wait_for => "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 = read_response_on_socket(socket)
+      headers, body = subject.read_response_on_socket(socket)
       headers.should eql("HTTP 200 OK")
       body.should eql("BODY")
     end
@@ -96,15 +98,15 @@ describe NginxTestHelper do
       socket.response1 = "X"
       socket.response2 = "Y"
 
-      headers, body = read_response_on_socket(socket)
+      headers, body = subject.read_response_on_socket(socket)
       headers.should eql("HTTP 200 OK")
       body.should eql("BODYXY")
     end
 
     it "should raise error if not receive a response" do
-      socket.stub!(:readpartial).and_raise(Exception)
+      socket.stub(:readpartial).and_raise(Exception)
 
-      expect { read_response_on_socket(socket) }.to raise_error("Any response")
+      expect { subject.read_response_on_socket(socket) }.to raise_error("Any response")
     end
 
     context "and receive a Errno::EAGAIN" do
@@ -114,7 +116,7 @@ describe NginxTestHelper do
           socket.response3 = "Z"
           socket.exception = Errno::EAGAIN
 
-          headers, body = read_response_on_socket(socket)
+          headers, body = subject.read_response_on_socket(socket)
           headers.should eql("HTTP 200 OK")
           body.should eql("BODYX")
         end
@@ -124,7 +126,7 @@ describe NginxTestHelper do
         it "should check if a text is present in the response" do
           socket.exception = Errno::EAGAIN
 
-          headers, body = read_response_on_socket(socket, "OD")
+          headers, body = subject.read_response_on_socket(socket, "OD")
           headers.should eql("HTTP 200 OK")
           body.should eql("BODY")
         end
@@ -133,9 +135,9 @@ describe NginxTestHelper do
           socket.exception = Errno::EAGAIN
           socket.response3 = "Z"
 
-          IO.should_receive(:select).with([socket]).any_number_of_times
+          IO.should_receive(:select).with([socket])
 
-          headers, body = read_response_on_socket(socket, "Z")
+          headers, body = subject.read_response_on_socket(socket, "Z")
           headers.should eql("HTTP 200 OK")
           body.should include("BODY")
         end
@@ -145,153 +147,150 @@ describe NginxTestHelper do
 
   context "when testing configuration" do
     before do
-      self.stub!(:config_id).and_return("config_id")
-      self.stub!(:start_server).and_return("Server started")
-      self.stub!(:stop_server).and_return("Server stoped")
+      subject.stub(:config_id).and_return("config_id")
+      subject.stub(:start_server).and_return("Server started")
+      subject.stub(: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)
-      nginx_test_configuration({:foo => "bar"})
+      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)
-      nginx_test_configuration
+      subject.nginx_test_configuration
     end
 
     it "should call start_server and stop_server methods" do
-      self.should_receive(:start_server).and_return("Server started")
-      self.should_receive(:stop_server).and_return("Server stoped")
-      nginx_test_configuration({:foo => "bar"})
+      subject.should_receive(:start_server).and_return("Server started")
+      subject.should_receive(:stop_server).and_return("Server stoped")
+      subject.nginx_test_configuration({:foo => "bar"})
     end
 
     it "should return start command result" do
-      nginx_test_configuration({:foo => "bar"}).should eql("Server started\n")
+      subject.nginx_test_configuration({:foo => "bar"}).should 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") }
-      nginx_test_configuration({:foo => "bar"}).should eql("Server started\nError log content")
+      subject.nginx_test_configuration({:foo => "bar"}).should eql("Server started\nError log content")
     end
   end
 
   context "when starting server to make tests" do
     before do
-      self.stub!(:config_id).and_return("config_id")
-      self.stub!(:start_server).and_return("Server started")
-      self.stub!(:stop_server).and_return("Server stoped")
+      subject.stub(:config_id).and_return("config_id")
+      subject.stub(:start_server).and_return("Server started")
+      subject.stub(: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)
-      nginx_run_server({:foo => "bar"}) {}
+      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)
-      nginx_run_server {}
+      subject.nginx_run_server {}
     end
 
     it "should execute the block after start_server and before stop_server methods" do
       obj = {:xyz => 1}
-      self.should_receive(:start_server).ordered
+      subject.should_receive(:start_server).ordered
       obj.should_receive(:delete).with(:xyz).ordered
-      self.should_receive(:stop_server).ordered
+      subject.should_receive(:stop_server).ordered
 
-      nginx_run_server({:foo => "bar"}) { obj.delete(:xyz) }
+      subject.nginx_run_server({:foo => "bar"}) { obj.delete(:xyz) }
     end
 
     it "should execute the block inside a timeout block" do
-      expect { nginx_run_server({:foo => "bar"}) { sleep 6 } }.to raise_error(Timeout::Error, "execution expired")
+      expect { subject.nginx_run_server({:foo => "bar"}) { sleep 6 } }.to raise_error(Timeout::Error, "execution expired")
     end
 
     it "should accept a custom a timeout" do
-      expect { nginx_run_server({:foo => "bar"}, {:timeout => 2}) { sleep 6 } }.to raise_error(Timeout::Error, "execution expired")
-      expect { nginx_run_server({:foo => "bar"}, {:timeout => 2}) { sleep 1 } }.to_not raise_error(Timeout::Error, "execution expired")
+      expect { subject.nginx_run_server({:foo => "bar"}, {:timeout => 2}) { sleep 6 } }.to raise_error(Timeout::Error, "execution expired")
+      expect { subject.nginx_run_server({:foo => "bar"}, {:timeout => 2}) { sleep 1 } }.to_not raise_error
     end
 
     it "should execute stop_server method if an exception was raised" do
-      self.should_receive(:stop_server)
-      expect { nginx_run_server({:foo => "bar"}) { raise "some error" } }.to raise_error("some error")
+      subject.should_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
-      self.stub!(:start_server).and_return("Server started")
-      self.stub!(:stop_server).and_return("Server stoped")
+      subject.stub(:start_server).and_return("Server started")
+      subject.stub(:stop_server).and_return("Server stoped")
+      subject.stub(:example).and_return(double)
     end
 
     context "and check config_id value" do
       it "should use example metadata if available" do
-        self.example.stub!(:metadata).and_return(:location => "./spec/test_config_id_spec.rb:100")
-        self.send(:config_id).should eql("test_config_id_spec_rb_100")
+        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")
       end
 
       it "should use method_name if example metadata is not available" do
-        self.example.stub!(:metadata).and_return(nil)
-        def method_name
-          "test_config_id_by_method_name"
-        end
-        self.send(:config_id).should eql("test_config_id_by_method_name")
+        subject.example.stub(:metadata).and_return(nil)
+        subject.stub(:method_name).and_return("test_config_id_by_method_name")
+
+        subject.send(:config_id).should eql("test_config_id_by_method_name")
       end
 
       it "should use __name__ if example metadata and method_name are not available" do
-        self.example.stub!(:metadata).and_return(nil)
-        def __name__
-          "test_config_id_by___name__"
-        end
-        self.send(:config_id).should eql("test_config_id_by___name__")
+        subject.example.stub(:metadata).and_return(nil)
+        subject.stub(:__name__).and_return("test_config_id_by___name__")
+
+        subject.send(:config_id).should 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
-          self.example.stub!(:exception).and_return(nil)
-          self.send(:has_passed?).should be_true
+          subject.example.stub(:exception).and_return(nil)
+          subject.send(:has_passed?).should be_true
         end
 
         it "should be 'false' if exception is not 'nil'" do
-          self.example.stub!(:exception).and_return("")
-          self.send(:has_passed?).should be_false
+          subject.example.stub(:exception).and_return("")
+          subject.send(:has_passed?).should be_false
         end
       end
 
       context "using 'test_passed' attribute if example exception is not available" do
-        before { self.example.stub!(:instance_variable_defined?).with(:@exception).and_return(false) }
-
         it "should be 'true' if 'test_passed' is 'true'" do
-          self.instance_variable_set(:@test_passed, true)
-          self.send(:has_passed?).should be_true
+          subject.instance_variable_set(:@test_passed, true)
+          subject.send(:has_passed?).should be_true
         end
 
         it "should be 'false' if 'test_passed' is 'false'" do
-          self.instance_variable_set(:@test_passed, false)
-          self.send(:has_passed?).should be_false
+          subject.instance_variable_set(:@test_passed, false)
+          subject.send(:has_passed?).should be_false
         end
       end
 
       context "using 'passed' attribute if example exception and 'test_passed' are not available" do
         before do
-          self.example.stub!(:instance_variable_defined?).with(:@exception).and_return(false)
-          self.instance_variable_set(:@test_passed, nil)
+          subject.example.stub(: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
-          self.instance_variable_set(:@passed, true)
-          self.send(:has_passed?).should be_true
+          subject.instance_variable_set(:@passed, true)
+          subject.send(:has_passed?).should be_true
         end
 
         it "should be 'false' if 'passed' is 'false'" do
-          self.instance_variable_set(:@passed, false)
-          self.send(:has_passed?).should be_false
+          subject.instance_variable_set(:@passed, false)
+          subject.send(:has_passed?).should be_false
         end
       end
     end
@@ -303,23 +302,23 @@ describe NginxTestHelper do
 
     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)
-      start_server(config)
+      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)
-      start_server(config)
+      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 { start_server(config) }.to raise_error("Server doesn't started - ")
+      expect { subject.start_server(config) }.to raise_error("Server doesn't started - ")
     end
 
     it "should return error message when the command fail" do
-      start_server(config).should eql("nginx: [emerg] unexpected end of file, expecting \";\" or \"}\" in /tmp/nginx_tests/config_id.conf:1")
+      subject.start_server(config).should eql("nginx: [emerg] unexpected end of file, expecting \";\" or \"}\" in /tmp/nginx_tests/config_id.conf:1")
     end
   end
 
@@ -329,23 +328,23 @@ describe NginxTestHelper do
 
     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)
-      stop_server(config)
+      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)
-      stop_server(config)
+      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 { stop_server(config) }.to raise_error("Server doesn't stoped - ")
+      expect { subject.stop_server(config) }.to raise_error("Server doesn't stoped - ")
     end
 
     it "should return error message when the command fail" do
-      stop_server(config).should eql("nginx: [emerg] unexpected end of file, expecting \";\" or \"}\" in /tmp/nginx_tests/config_id.conf:1")
+      subject.stop_server(config).should eql("nginx: [emerg] unexpected end of file, expecting \";\" or \"}\" in /tmp/nginx_tests/config_id.conf:1")
     end
   end
 

data/spec/spec_helper.rb

@@ -27,9 +27,6 @@ rescue LoadError
   # ignore simplecov in ruby < 1.9
 end
 
-# Requires lib.
-Dir[File.expand_path('../lib/**/*.rb', File.dirname(__FILE__))].each { |f| require f }
-
 def with_constants(constants, &block)
   old_verbose, $VERBOSE = $VERBOSE, nil
   saved_constants = {}

metadata

@@ -1,78 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: nginx_test_helper
 version: !ruby/object:Gem::Version
-  version: 0.2.0
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Wandenberg Peixoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-17 00:00:00.000000000 Z
+date: 2014-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: popen4
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.10.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.10.0
 - !ruby/object:Gem::Dependency
   name: debugger
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.1.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.1.3
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.0.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.0.1
 description: A collection of helper methods to test your nginx module.
@@ -110,27 +101,26 @@ files:
 - templates/spec/nginx_configuration.rb
 homepage: ''
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A collection of helper methods to test your nginx module.
 test_files:
 - spec/nginx_test_helper/command_line_tool_spec.rb