nginx_test_helper 0.0.1

data/spec/nginx_test_helper/config_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe NginxTestHelper::Config do
+  let(:configuration) { {} }
+  let(:subject) { NginxTestHelper::Config.new("config_id", configuration) }
+
+  it "should include NginxTestHelper module" do
+    subject.class.included_modules.should 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")
+  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])
+  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])
+  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
+  end
+
+  it "should create the configuration file using the template configuration" do
+    File.read(subject.configuration[:configuration_filename]).should 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"')
+    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
+  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)
+  end
+
+  it "should raise exception if configuration key does not exists" do
+    config = NginxTestHelper::Config.new("config_id", { :foo => "bar"})
+    expect { config.xyz }.to raise_error(NameError, "undefined local variable, method or configuration 'xyz'")
+  end
+
+  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)
+  end
+
+  context "when using the write_directive helper method" do
+    let(:configuration) { {:foo => "bar", :xyz => nil, :configuration_template => %(\n<%= write_directive('name', foo, 'comment foo') %>\n<%= write_directive('without_comment', foo) %>\n<%= write_directive('xyz', xyz, 'comment xyz') %>\n<%= write_directive('xyz_without_comment', xyz) %>)} }
+
+    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 "";))
+    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";))
+    end
+  end
+end

data/spec/nginx_test_helper/env_methods_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+class SomeClass
+  include NginxTestHelper::EnvMethods
+end
+
+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")
+      end
+
+      it "should return nginx host" do
+        subject.nginx_host.should eql("127.0.0.1")
+      end
+
+      it "should return nginx port" do
+        subject.nginx_port.should eql("9990")
+      end
+
+      it "should return nginx workers" do
+        subject.nginx_workers.should eql("1")
+      end
+
+      it "should return nginx tests tmp dir" do
+        subject.nginx_tests_tmp_dir.should eql("/tmp/nginx_tests")
+      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")
+      end
+
+      it "should return nginx host" do
+        ENV['NGINX_HOST'] = "some_host"
+        subject.nginx_host.should eql("some_host")
+      end
+
+      it "should return nginx port" do
+      ENV['NGINX_PORT'] = "some_port"
+        subject.nginx_port.should eql("some_port")
+      end
+
+      it "should return nginx workers" do
+        ENV['NGINX_WORKERS'] = "25"
+        subject.nginx_workers.should 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")
+      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")
+
+      subject.nginx_address.should eql("http://some_host:some_port")
+    end
+  end
+
+  context "when a class include the NginxTestHelper::EnvMethods module" do
+    let(:subject) { SomeClass }
+
+    it_should_behave_like "has nginx configuration methods"
+
+    context "their object instances" do
+      let(:subject) { SomeClass.new }
+
+      it_should_behave_like "has nginx configuration methods"
+    end
+  end
+
+end

data/spec/nginx_test_helper/rspec_utils_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe "rspec_utils" do
+
+  it "should include NginxTestHelper module on RSpec tests" do
+    self.class.included_modules.should 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
+      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
+      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
+      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")
+      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")
+      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
+      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")
+      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")
+      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")
+      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
+      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
+      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
+      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")
+    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
+      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/'")
+      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'")
+      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
+      end
+    end
+
+    it "should has a friendly description" do
+      match_the_pattern(/EX/i).description.should eql("match the pattern '/EX/i'")
+    end
+  end
+end

data/spec/nginx_test_helper_spec.rb

@@ -0,0 +1,320 @@
+require 'spec_helper'
+
+describe NginxTestHelper do
+  include NginxTestHelper
+
+  it "should define a method with basic headers" do
+    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)
+  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)
+  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)
+
+      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.0\r\n\r\n")
+
+      headers, body = get_in_socket("/index.html", socket)
+      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.0\r\n\r\n")
+      self.should_receive(:read_response_on_socket).with(socket, "wait for")
+
+      get_in_socket("/index.html", socket, "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.0\r\nContent-Length: 4\r\n\r\nBODY")
+
+      headers, body = post_in_socket("/service", "BODY", socket)
+      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.0\r\nContent-Length: 4\r\n\r\nBODY")
+      self.should_receive(:read_response_on_socket).with(socket, "wait for")
+
+      headers, body = post_in_socket("/service", "BODY", socket, "wait for")
+    end
+
+    it "should be possible read a response in a opened socket" do
+      headers, body = read_response_on_socket(socket)
+      headers.should eql("HTTP 200 OK")
+      body.should eql("BODY")
+    end
+
+    it "should concatenate response parts" do
+      socket.response1 = "X"
+      socket.response2 = "Y"
+
+      headers, body = 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)
+
+      expect { read_response_on_socket(socket) }.to raise_error("Any response")
+    end
+
+    context "and receive a Errno::EAGAIN" do
+      context "and not give a text to wait for" do
+        it "should return what was received until the error happens" do
+          socket.response1 = "X"
+          socket.response3 = "Z"
+          socket.exception = Errno::EAGAIN
+
+          headers, body = read_response_on_socket(socket)
+          headers.should eql("HTTP 200 OK")
+          body.should eql("BODYX")
+        end
+      end
+
+      context "and give a text to wait for" 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.should eql("HTTP 200 OK")
+          body.should 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]).any_number_of_times
+
+          headers, body = read_response_on_socket(socket, "Z")
+          headers.should eql("HTTP 200 OK")
+          body.should include("BODY")
+        end
+      end
+    end
+  end
+
+  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")
+    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"})
+    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
+    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"})
+    end
+
+    it "should return start command result" do
+      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")
+    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")
+    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"}) {}
+    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 {}
+    end
+
+    it "should execute the block after start_server and before stop_server methods" do
+      obj = {:xyz => 1}
+      self.should_receive(:start_server).ordered
+      obj.should_receive(:delete).with(:xyz).ordered
+      self.should_receive(:stop_server).ordered
+
+      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")
+    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")
+    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")
+    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")
+    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")
+      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")
+      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__")
+      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
+        end
+
+        it "should be 'false' if exception is not 'nil'" do
+          self.example.stub!(:exception).and_return("")
+          self.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
+        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
+        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)
+        end
+
+        it "should be 'true' if 'passed' is 'true'" do
+          self.instance_variable_set(:@passed, true)
+          self.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
+        end
+      end
+    end
+  end
+
+  context "when starting the server" do
+    let(:config) { NginxTestHelper::Config.new("config_id", {}) }
+    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)
+      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)
+    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 - ")
+    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")
+    end
+  end
+
+  context "when stoping the server" do
+    let(:config) { NginxTestHelper::Config.new("config_id", {}) }
+    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)
+      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)
+    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 - ")
+    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")
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,85 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper.rb"` to ensure that it is only
+# loaded once.
+#
+# 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.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.before do
+    FileUtils.rm_rf("/tmp/nginx_tests")
+    ENV.each_key do |key|
+      ENV.delete(key) if key.start_with?("NGINX_")
+    end
+  end
+end
+
+begin
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/spec/'
+  end
+  SimpleCov.coverage_dir 'coverage'
+rescue LoadError
+  # ignore simplecov in ruby < 1.9
+end
+
+# Requires lib.
+Dir[File.expand_path('../lib/**/*.rb', File.dirname(__FILE__))].each { |f| require f }
+
+module NginxConfiguration
+  def self.default_configuration
+    {
+      :conf_item => "conf_value"
+    }
+  end
+
+  def self.template_configuration
+    %("template configuration <%= config_id %>")
+  end
+end
+
+class SocketMock
+  attr_accessor :response1, :response2, :response3, :exception
+
+  def initialize
+    @step = 0
+    @response1 = ""
+    @response2 = ""
+    @response3 = ""
+    @exception = "just to force go out of the loop"
+  end
+
+  def print(content)
+  end
+
+  def readpartial(count)
+    "HTTP 200 OK\r\n\r\nBODY"
+  end
+
+  def read_nonblock(count)
+    @step += 1
+    if @step == 1
+      @response1
+    elsif @step == 2
+      @response2
+    elsif @step == 3
+      raise @exception unless @exception.nil?
+    elsif @step == 4
+      @response3
+    else
+      raise @exception unless @exception.nil?
+    end
+  end
+end
+
+class Status
+  attr_accessor :exitstatus
+
+  def initialize
+    @exitstatus = 0
+  end
+end

data/templates/INSTALL

@@ -0,0 +1,8 @@
+Nginx Test Helper has been installed with example specs.
+
+Edit the file 'spec/nginx_configuration.rb'
+setting your module configuration template on 'template_configuration' method
+and your default configuration values on 'default_configuration' method.
+
+On 'spec/example_spec.rb' file has some examples of how can you do your tests.
+