nginx_test_helper 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.rvmrc
+.project
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in nginx_test_helper.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Wandenberg Peixoto
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,141 @@
+# NginxTestHelper
+
+A collection of helper methods to test your nginx module.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'nginx_test_helper'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nginx_test_helper
+
+## Usage
+
+Create a module called NginxConfiguration with two class methods:
+`default_configuration`, which should return a hash with the default configuration values, and `template_configuration` which should return the Nginx configuration template.
+
+You can use the command bellow to generate this file
+
+    $ nginx_test_helper init
+
+The init command also create a example_spec.rb to show how to use the main methods:
+
+### nginx_test_configuration
+
+Starts the server with the given configuration and template, stop it and return the `stderr` and `error log` to be possible to check some condition.
+
+    nginx_test_configuration({:unknown_value => 0}).should include('unknown directive "unknown_directive"')
+
+### nginx_run_server
+
+Starts the server, execute the given block inside a `Timeout block` and stop the server.
+
+    nginx_run_server({:return_code => 422}) do
+      uri = URI.parse("http://#{nginx_host}:#{nginx_port}/")
+      response = Net::HTTP.get_response(uri)
+      response.code.should eql("422")
+    end
+
+You can customize the timeout value, default 5 seconds, using the second parameter of `nginx_run_server` method.
+
+    nginx_run_server({}, {:timeout => 1}) do
+      sleep 2
+    end
+
+### start_server / stop_server
+
+If you want to start the server and run many test cases with the same configuration you can use `start_server / stop_server` methods.
+
+    before(:all) do
+      configuration = {} # Your configuration hash
+      @config = NginxTestHelper::Config.new("example_config_id", configuration)
+      start_server(@config)
+    end
+
+    after(:all) do
+      stop_server(@config)
+    end
+
+### delete_config_and_log_files
+
+You can use this method to delete the files created by configuration.
+One usecase is call it after the test, if it has passed, like:
+
+	RSpec.configure do |config|
+	  config.after(:each) do
+	    NginxTestHelper::Config.delete_config_and_log_files(config_id) if has_passed?
+	  end
+	end
+
+## Environment variables
+
+Some default values can be overwriten by environment variables.
+Check the list bellow:
+
+1. NGINX_EXEC - set which nginx executable to be used on tests, default: '/usr/local/nginx/sbin/nginx'
+2. NGINX_HOST - set the host returned by `nginx_host` method, default: '127.0.0.1'
+3. NGINX_PORT - set the port returned by `nginx_port` method, default: 9990
+4. NGINX_WORKERS - set the number of workers returned by `nginx_workers` method, default: 1
+5. NGINX_TESTS_TMP_DIR - set the dir where temporary files, logs and configuration files, will be stored, default: '/tmp/nginx_tests'
+
+## Easter eggs
+
+### configuration_template
+
+You can set a key named `configuration_template` on your configuration with a template different from the one on `template_configuration` method to be used when writing configuration file.
+
+### disable_start_stop_server
+
+You can set a key named `disable_start_stop_server` on your configuration with `true` value to avoid the start and stop server steps. This can be useful when debugging how a test is failing.
+
+### write_directive
+
+You can use the method `write_directive` on your configuration template to be easier to deal with null values.
+
+    write_directive("directive_name", value)
+
+    with value = nil results in
+    #directive_name "";
+
+    with value != nil, 10 as example, results in
+    directive_name "10";
+
+There is a third optional parameter which is used as comment to directive.
+
+    write_directive("directive_name", 10, "directive comment")
+
+    #directive comment
+    directive_name "10";
+
+## Matchers
+
+There are two available mathers.
+
+### be_in_the_interval
+
+To check if the value is in a range, `>= min` and `<= max`
+
+    10.5.should be_in_the_interval(10.3, 10.6) # true
+    10.5.should be_in_the_interval(10.6, 10.8) # false
+
+### match_the_pattern
+
+To check if the value match the given pattern
+
+   "foo".should match_the_pattern(/O/i) # true
+   "foo".should match_the_pattern(/A/i) # false
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[--color --format documentation]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => [:spec]

data/bin/nginx_test_helper

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'nginx_test_helper'
+
+NginxTestHelper::CommandLineTool.new.process ARGV

data/lib/nginx_test_helper/command_line_tool.rb

@@ -0,0 +1,59 @@
+module NginxTestHelper
+  class CommandLineTool
+    def cwd
+      File.expand_path(File.join(File.dirname(__FILE__), '../../'))
+    end
+
+    def expand(*paths)
+      File.expand_path(File.join(*paths))
+    end
+
+    def template_path(filepath)
+      expand(cwd, File.join("templates", filepath))
+    end
+
+    def dest_path(filepath)
+      expand(Dir.pwd, filepath)
+    end
+
+    def copy_unless_exists(relative_path, dest_path = nil)
+      unless File.exist?(dest_path(relative_path))
+        FileUtils.copy(template_path(relative_path), dest_path(dest_path || relative_path))
+      end
+    end
+
+    def process(argv)
+      if argv[0] == 'init'
+        require 'fileutils'
+
+        FileUtils.makedirs(dest_path('spec'))
+
+        copy_unless_exists('spec/nginx_configuration.rb')
+        copy_unless_exists('spec/example_spec.rb')
+        copy_unless_exists('spec/example2_spec.rb')
+
+        write_mode = 'w'
+        if File.exist?(dest_path('spec/spec_helper.rb'))
+          load dest_path('spec/spec_helper.rb')
+          write_mode = 'a'
+        end
+
+        unless Object.const_defined?('NginxConfiguration') && write_mode == 'a'
+          File.open(dest_path('spec/spec_helper.rb'), write_mode) do |f|
+            f.write("\nrequire File.expand_path('nginx_configuration', File.dirname(__FILE__))")
+          end
+        end
+
+        File.open(template_path('INSTALL'), 'r').each_line do |line|
+          puts line
+        end
+      elsif argv[0] == "license"
+        puts File.new(expand(cwd, "LICENSE")).read
+      else
+        puts "unknown command #{argv}"
+        puts "Usage: nginx_test_helper init"
+        puts "                         license"
+      end
+    end
+  end
+end

data/lib/nginx_test_helper/config.rb

@@ -0,0 +1,70 @@
+require "erb"
+
+module NginxTestHelper
+  class Config
+
+    include NginxTestHelper::EnvMethods
+
+    attr_reader :config_id, :configuration
+
+    def initialize(config_id, configuration)
+      @config_id = config_id
+      @configuration = NginxConfiguration.default_configuration.merge(configuration).merge(Config.files_and_dirs(config_id))
+
+      Config.create_dirs
+      create_configuration_file
+    end
+
+    def create_configuration_file
+      configuration_template = configuration.delete(:configuration_template)
+      template = ERB.new configuration_template || NginxConfiguration.template_configuration
+      File.open(configuration[:configuration_filename], 'w') {|f| f.write(template.result(get_binding)) }
+    end
+
+    def respond_to?(m)
+      super(m) || configuration.has_key?(m.to_sym)
+    end
+
+    def method_missing(m, *args, &block)
+      raise NameError, "undefined local variable, method or configuration '#{m}'" unless configuration.has_key?(m.to_sym)
+      configuration[m.to_sym]
+    end
+
+    def write_directive(name, value, comment=nil)
+      directive = []
+      directive << %(##{comment}) unless comment.nil?
+      directive << %(#{"#" if value.nil?}#{name} "#{value}";)
+      directive.join("\n")
+    end
+
+    def get_binding
+      binding
+    end
+
+    class << self
+      def create_dirs
+        FileUtils.mkdir_p("#{nginx_tests_tmp_dir}/logs") unless File.directory?("#{nginx_tests_tmp_dir}/logs")
+        FileUtils.mkdir_p("#{nginx_tests_tmp_dir}/client_body_temp") unless File.directory?("#{nginx_tests_tmp_dir}/client_body_temp")
+      end
+
+      def files_and_dirs(config_id)
+        {
+          :configuration_filename => File.expand_path("#{nginx_tests_tmp_dir}/#{config_id}.conf"),
+          :pid_file => File.expand_path("#{nginx_tests_tmp_dir}/nginx.pid"),
+          :access_log => File.expand_path("#{nginx_tests_tmp_dir}/logs/access-#{config_id}.log"),
+          :error_log => File.expand_path("#{nginx_tests_tmp_dir}/logs/error-#{config_id}.log"),
+          :client_body_temp => File.expand_path("#{nginx_tests_tmp_dir}/client_body_temp")
+        }
+      end
+
+      def delete_config_and_log_files(config_id)
+        items = files_and_dirs(config_id)
+
+        File.delete(items[:configuration_filename]) if File.exist?(items[:configuration_filename])
+        File.delete(items[:access_log]) if File.exist?(items[:access_log])
+        File.delete(items[:error_log]) if File.exist?(items[:error_log])
+        FileUtils.rm_rf(items[:client_body_temp]) if File.exist?(items[:client_body_temp])
+      end
+    end
+  end
+end

data/lib/nginx_test_helper/env_methods.rb

@@ -0,0 +1,35 @@
+module NginxTestHelper
+  module EnvMethods
+    module ClassMethods
+      def nginx_address
+        "http://#{nginx_host}:#{nginx_port}"
+      end
+
+      def nginx_executable
+        ENV['NGINX_EXEC'].nil? ? "/usr/local/nginx/sbin/nginx" : ENV['NGINX_EXEC']
+      end
+
+      def nginx_host
+        ENV['NGINX_HOST'].nil? ? "127.0.0.1" : ENV['NGINX_HOST']
+      end
+
+      def nginx_port
+        ENV['NGINX_PORT'].nil? ? "9990" : ENV['NGINX_PORT']
+      end
+
+      def nginx_workers
+        ENV['NGINX_WORKERS'].nil? ? "1" : ENV['NGINX_WORKERS']
+      end
+
+      def nginx_tests_tmp_dir
+        ENV['NGINX_TESTS_TMP_DIR'].nil? ? "/tmp/nginx_tests" : ENV['NGINX_TESTS_TMP_DIR']
+      end
+    end
+
+    include ClassMethods
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/nginx_test_helper/rspec_utils.rb

@@ -0,0 +1,41 @@
+if defined?(RSpec)
+  RSpec.configure do |config|
+    config.include NginxTestHelper
+  end
+
+  RSpec::Matchers.define :be_in_the_interval do |min, max|
+    match do |actual|
+      (actual >= min) && (actual <= max)
+    end
+
+    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
+
+    description do
+      "be in the interval from #{min} to #{max}"
+    end
+  end
+
+  RSpec::Matchers.define :match_the_pattern do |pattern|
+    match do |actual|
+      actual.match(pattern)
+    end
+
+    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
+
+    description do
+      "match the pattern '#{pattern.inspect}'"
+    end
+  end
+end

data/lib/nginx_test_helper/version.rb

@@ -0,0 +1,3 @@
+module NginxTestHelper
+  VERSION = "0.0.1"
+end

data/lib/nginx_test_helper.rb

@@ -0,0 +1,118 @@
+require "nginx_test_helper/version"
+require "nginx_test_helper/env_methods"
+require "nginx_test_helper/config"
+require "nginx_test_helper/rspec_utils"
+require "nginx_test_helper/command_line_tool"
+require "popen4"
+require 'timeout'
+
+module NginxTestHelper
+  include NginxTestHelper::EnvMethods
+
+  def nginx_run_server(configuration={}, options={}, &block)
+    config = Config.new(config_id, configuration)
+    start_server(config)
+    Timeout::timeout(options[:timeout] || 5) do
+      block.call(config)
+    end
+  ensure
+    stop_server(config) unless config.nil?
+  end
+
+  def nginx_test_configuration(configuration={})
+    config = Config.new(config_id, configuration)
+    stderr_msg = start_server(config)
+    stop_server(config)
+    "#{stderr_msg}\n#{File.read(config.error_log) if File.exists?(config.error_log)}"
+  end
+
+  def open_socket(host, port)
+    TCPSocket.open(host, port)
+  end
+
+  def get_in_socket(url, socket, wait_for=nil)
+    socket.print("GET #{url} HTTP/1.0\r\n\r\n")
+    read_response_on_socket(socket, wait_for)
+  end
+
+  def post_in_socket(url, body, socket, wait_for=nil)
+    socket.print("POST #{url} HTTP/1.0\r\nContent-Length: #{body.size}\r\n\r\n#{body}")
+    read_response_on_socket(socket, wait_for)
+  end
+
+  def read_response_on_socket(socket, wait_for=nil)
+    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))
+      IO.select([socket])
+      retry
+    end
+  ensure
+    fail("Any response") if response.nil?
+    headers, body = response.split("\r\n\r\n", 2)
+    return headers, body
+  end
+
+  def time_diff_milli(start, finish)
+     ((finish - start) * 1000.0).to_i
+  end
+
+  def time_diff_sec(start, finish)
+     (finish - start).to_i
+  end
+
+  def headers
+    {'accept' => 'text/html'}
+  end
+
+  def start_server(config)
+    error_message = ""
+    unless config.configuration[:disable_start_stop_server]
+      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
+    end
+    error_message
+  end
+
+  def stop_server(config)
+    error_message = ""
+    unless config.configuration[:disable_start_stop_server]
+      status = POpen4::popen4("#{ config.nginx_executable } -c #{ config.configuration_filename } -s stop") 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 stoped - #{error_message}") unless status.exitstatus == 0
+    end
+    error_message
+  end
+
+private
+  def config_id
+    if 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(/[\.\:]/, '_')
+    elsif self.respond_to?('method_name')
+      self.method_name
+    else
+      self.__name__
+    end
+  end
+
+  def has_passed?
+    if self.respond_to?(:example) && !self.example.nil? && self.example.instance_variable_defined?(:@exception)
+      self.example.exception.nil?
+    elsif !@test_passed.nil?
+      @test_passed
+    else
+      @passed
+    end
+  end
+end

data/nginx_test_helper.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/nginx_test_helper/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Wandenberg Peixoto"]
+  gem.email         = ["wandenberg@gmail.com"]
+  gem.description   = %q{A collection of helper methods to test your nginx module.}
+  gem.summary       = %q{A collection of helper methods to test your nginx module.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "nginx_test_helper"
+  gem.require_paths = ["lib"]
+  gem.version       = NginxTestHelper::VERSION
+
+  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<simplecov>, [">= 0.0.1"]) if RUBY_VERSION > "1.9.0"
+end

data/spec/nginx_test_helper/command_line_tool_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe NginxTestHelper::CommandLineTool do
+  before do
+    $stdout.stub!(:puts)
+    Dir.stub!(:pwd).and_return('tmp')
+    FileUtils.mkdir_p('tmp/spec')
+  end
+
+  after do
+    FileUtils.rm_rf('tmp')
+  end
+
+  it "should list available options" do
+    $stdout.should_receive(:puts).with(/init/)
+    $stdout.should_receive(:puts).with(/license/)
+    NginxTestHelper::CommandLineTool.new.process []
+  end
+
+  it "should list the gem license" do
+    $stdout.should_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
+
+    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')
+  end
+
+  it "should include require call on spec_helper if NgincConfiguration is not defined" do
+    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__))")
+  end
+
+  it "should print INSTALL file content" do
+    $stdout.should_receive(:puts).with(/Nginx Test Helper has been installed with example specs./)
+    NginxTestHelper::CommandLineTool.new.process ["init"]
+  end
+end