passenger 5.0.4 → 5.0.5

data/test/ruby/utils/hosts_file_parser.rb

@@ -1,258 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-PhusionPassenger.require_passenger_lib 'utils/hosts_file_parser'
-require 'stringio'
-
-module PhusionPassenger
-
-describe Utils::HostsFileParser do
-  before :each do
-    @io = StringIO.new
-  end
-
-  def create
-    @io.rewind
-    @parser = Utils::HostsFileParser.new(@io)
-  end
-
-  describe "parsing" do
-    it "ignores comments" do
-      @io.puts("# 127.0.0.1 foo.com")
-      create
-      @parser.ip_count.should == 0
-      @parser.host_count.should == 0
-    end
-
-    it "ignores comments that come after leading spaces" do
-      @io.puts("   # 127.0.0.1 foo.com")
-      create
-      @parser.ip_count.should == 0
-      @parser.host_count.should == 0
-    end
-
-    it "ignores comments that come after leading tabs" do
-      @io.puts("\t# 127.0.0.1 foo.com")
-      create
-      @parser.ip_count.should == 0
-      @parser.host_count.should == 0
-    end
-
-    it "ignores empty lines" do
-      @io.puts("127.0.0.1 foo.com")
-      @io.puts
-      @io.puts("127.0.0.1 bar.com")
-      @io.puts("127.0.0.2 baz.com")
-      create
-      @parser.ip_count.should == 2
-      @parser.host_count.should == 3
-    end
-
-    it "ignores leading and trailing spaces" do
-      @io.puts("  127.0.0.1 foo.com")
-      @io.puts
-      @io.puts("  127.0.0.1 bar.com  ")
-      @io.puts("127.0.0.2 baz.com  ")
-      create
-      @parser.ip_count.should == 2
-      @parser.host_count.should == 3
-      @parser.resolve("foo.com").should == "127.0.0.1"
-      @parser.resolve("bar.com").should == "127.0.0.1"
-      @parser.resolve("baz.com").should == "127.0.0.2"
-    end
-
-    it "ignores leading and trailing tabs" do
-      @io.puts("\t\t127.0.0.1 foo.com")
-      @io.puts
-      @io.puts("\t127.0.0.1 bar.com\t")
-      @io.puts("127.0.0.2 baz.com\t\t")
-      create
-      @parser.ip_count.should == 2
-      @parser.host_count.should == 3
-      @parser.resolve("foo.com").should == "127.0.0.1"
-      @parser.resolve("bar.com").should == "127.0.0.1"
-      @parser.resolve("baz.com").should == "127.0.0.2"
-    end
-
-    it "correctly handles spaces as seperators" do
-      @io.puts("127.0.0.1 foo.com bar.com  baz.com")
-      create
-      @parser.ip_count.should == 1
-      @parser.host_count.should == 3
-      @parser.resolve("foo.com").should == "127.0.0.1"
-      @parser.resolve("bar.com").should == "127.0.0.1"
-      @parser.resolve("baz.com").should == "127.0.0.1"
-    end
-
-    it "correctly handles tabs as seperators" do
-      @io.puts("127.0.0.1\tfoo.com\t\tbar.com baz.com")
-      create
-      @parser.ip_count.should == 1
-      @parser.host_count.should == 3
-      @parser.resolve("foo.com").should == "127.0.0.1"
-      @parser.resolve("bar.com").should == "127.0.0.1"
-      @parser.resolve("baz.com").should == "127.0.0.1"
-    end
-  end
-
-  describe "#resolve" do
-    it "returns nil if the host name is not in the file" do
-      @io.puts("127.0.0.1 foo.com")
-      create
-      @parser.resolve("bar.com").should be_nil
-    end
-
-    it "returns the IP address associated with the host name if it exists" do
-      @io.puts("255.255.255.255 foo.com")
-      create
-      @parser.resolve("foo.com").should == "255.255.255.255"
-    end
-
-    it "is case-insensitive" do
-      @io.puts("255.255.255.255 fOO.com")
-      create
-      @parser.resolve("foo.COM").should == "255.255.255.255"
-    end
-
-    it "correctly handles lines that contain multiple host names" do
-      @io.puts("255.255.255.255 foo.com bar.com")
-      create
-      @parser.resolve("foo.com").should == "255.255.255.255"
-      @parser.resolve("bar.com").should == "255.255.255.255"
-      @parser.resolve("baz.com").should be_nil
-    end
-
-    it "always returns 127.0.0.1 for localhost" do
-      create
-      @parser.resolve("localhost").should == "127.0.0.1"
-      @parser.resolve("localHOST").should == "127.0.0.1"
-    end
-  end
-
-  describe "#resolves_to_localhost?" do
-    before :each do
-      @io.puts "127.0.0.1 kotori"
-      @io.puts "192.168.0.1 kanako"
-      @io.puts "::1 ageha"
-      @io.puts "::2 sawako"
-      @io.puts "0.0.0.0 mizusawa"
-      create
-    end
-
-    it "returns true if the host name resolves to 127.0.0.1" do
-      @parser.resolves_to_localhost?("kotori").should be_true
-    end
-
-    it "returns true if the host name resolves to ::1" do
-      @parser.resolves_to_localhost?("ageha").should be_true
-    end
-
-    it "returns true if the host name resolves to 0.0.0.0" do
-      @parser.resolves_to_localhost?("mizusawa").should be_true
-    end
-
-    it "returns false if the host name resolves to something else" do
-      @parser.resolves_to_localhost?("sawako").should be_false
-      @parser.resolves_to_localhost?("kanako").should be_false
-    end
-
-    it "returns false if the host name does not resolve" do
-      @parser.resolves_to_localhost?("foo.com").should be_false
-    end
-  end
-
-  describe "#add_group_data" do
-    before :each do
-      @standard_entries =
-        "127.0.0.1 kotori hazuki\n" +
-        "  192.168.0.1 kanako\n\n" +
-        "\t::1 ageha sawako\n" +
-        "0.0.0.0 mizusawa naru\n"
-      @target = StringIO.new
-    end
-
-    it "adds the group data if it doesn't exist" do
-      @io.puts @standard_entries
-      create
-
-      @parser.add_group_data("some marker",
-        "# a comment\n" +
-        "127.0.0.1 foo\n")
-      @parser.write(@target)
-      @target.string.should ==
-        @standard_entries +
-        "###### BEGIN some marker ######\n" +
-        "# a comment\n" +
-        "127.0.0.1 foo\n" +
-        "###### END some marker ######\n"
-    end
-
-    it "replaces the existing group data if it does exist" do
-      @io.puts "###### BEGIN some marker ######\n" +
-        "# another comment\n" +
-        "127.0.0.1 bar\n" +
-        "###### END some marker ######\n" +
-        "\n" +
-        @standard_entries +
-        "###### BEGIN some other marker ######\n" +
-        "# another comment\n" +
-        "127.0.0.1 bar\n" +
-        "###### END some other marker ######\n"
-      create
-
-      @parser.add_group_data("some marker", "127.0.0.1 foo\n")
-      @parser.write(@target)
-      @target.string.should ==
-        "###### BEGIN some marker ######\n" +
-        "127.0.0.1 foo\n" +
-        "###### END some marker ######\n" +
-        "\n" +
-        @standard_entries +
-        "###### BEGIN some other marker ######\n" +
-        "# another comment\n" +
-        "127.0.0.1 bar\n" +
-        "###### END some other marker ######\n"
-    end
-
-    it "correctly handles the lack of a terminating newline in the group data" do
-      @io.puts @standard_entries
-      create
-
-      @parser.add_group_data("some marker",
-        "# a comment\n" +
-        "127.0.0.1 foo")
-      @parser.write(@target)
-      @target.string.should ==
-        @standard_entries +
-        "###### BEGIN some marker ######\n" +
-        "# a comment\n" +
-        "127.0.0.1 foo\n" +
-        "###### END some marker ######\n"
-    end
-
-    it "ensures that the group data starts at a new line" do
-      @io.write "127.0.0.1 foo.com"
-      create
-      @parser.add_group_data("some marker", "127.0.0.1 bar.com")
-      @parser.write(@target)
-      @target.string.should ==
-        "127.0.0.1 foo.com\n" +
-        "###### BEGIN some marker ######\n" +
-        "127.0.0.1 bar.com\n" +
-        "###### END some marker ######\n"
-    end
-  end
-
-  describe "#write" do
-    it "preserves all comments and leading and trailing whitespaces" do
-      @io.puts "127.0.0.1 foo.com  "
-      @io.puts "# a comment"
-      @io.puts "\t127.0.0.1  bar.com\t"
-      create
-      original_data = @io.string
-      target = StringIO.new
-      @parser.write(target)
-      target.string.should == original_data
-    end
-  end
-end
-
-end # module PhusionPassenger

data/test/ruby/utils/tee_input_spec.rb

@@ -1,235 +0,0 @@
-# encoding: binary
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-PhusionPassenger.require_passenger_lib 'utils/tee_input'
-require 'stringio'
-
-module PhusionPassenger
-
-shared_examples "TeeInput#gets" do
-  context "if Content-Length is given" do
-    before :each do
-      init_input("hello\nworld\nlast line!", "CONTENT_LENGTH" => 21)
-    end
-
-    it "reads a line, including newline character" do
-      @input.gets.should == "hello\n"
-      @input.gets.should == "world\n"
-    end
-
-    it "reads until EOF if no newline is encountered before EOF" do
-      @input.gets
-      @input.gets
-      @input.gets.should == "last line"
-    end
-
-    it "returns nil if EOF is reached" do
-      @input.gets
-      @input.gets
-      @input.gets
-      @input.gets.should be_nil
-    end
-  end
-
-  context "if Transfer-Encoding is chunked" do
-    before :each do
-      init_input("hello\nworld\nlast line", "TRANSFER_ENCODING" => "chunked")
-    end
-
-    it "reads a line, including newline character" do
-      @input.gets.should == "hello\n"
-      @input.gets.should == "world\n"
-    end
-
-    it "reads until EOF if no newline is encountered before EOF" do
-      @input.gets
-      @input.gets
-      @input.gets.should == "last line"
-    end
-
-    it "returns nil if EOF is reached" do
-      @input.gets
-      @input.gets
-      @input.gets
-      @input.gets.should be_nil
-    end
-  end
-
-  context "if neither Content-Length nor Transfer-Encoding chunked are given" do
-    before :each do
-      init_input("hello\nworld\nlast line")
-    end
-
-    it "returns nil" do
-      @input.gets.should be_nil
-    end
-  end
-end
-
-shared_examples "TeeInput#read" do
-  describe "with no arguments" do
-    context "if Content-Length is given" do
-      before :each do
-        init_input("hello!", "CONTENT_LENGTH" => 5)
-      end
-
-      it "slurps up to Content-Length bytes from the socket" do
-        @input.read.should == "hello"
-      end
-
-      it "returns the empty string if EOF is reached" do
-        @input.read
-        @input.read.should == ""
-      end
-    end
-
-    context "if Transfer-Encoding is chunked" do
-      before :each do
-        init_input("hello!", "TRANSFER_ENCODING" => "chunked")
-      end
-
-      it "slurps the entire socket" do
-        @input.read.should == "hello!"
-      end
-
-      it "returns the empty string if EOF is reached" do
-        @input.read
-        @input.read.should == ""
-      end
-    end
-
-    context "if neither Content-Length nor Transfer-Encoding chunked are given" do
-      before :each do
-        init_input("hello!")
-      end
-
-      it "returns the empty string" do
-        @input.read.should == ""
-      end
-    end
-  end
-
-  describe "with a length argument" do
-    it "raises ArgumentError if len < 0" do
-      init_input("")
-      lambda { @input.read(-1) }.should raise_error(ArgumentError)
-    end
-
-    it "returns the empty string if len == 0" do
-      init_input("hello", "TRANSFER_ENCODING" => "chunked")
-      @input.read(0).should == ""
-    end
-
-    context "if Content-Length is given" do
-      before :each do
-        init_input("hello!", "CONTENT_LENGTH" => 5)
-      end
-
-      it "reads exactly len bytes if available" do
-        @input.read(2).should == "he"
-        @input.read(2).should == "ll"
-      end
-
-      it "reads at most Content-Length bytes if Content-Length < len are available" do
-        @input.read(2).should == "he"
-        @input.read(4).should == "llo"
-      end
-
-      it "returns nil if Content-Length is reached" do
-        @input.read(5).should == "hello"
-        @input.read(1).should be_nil
-      end
-    end
-
-    context "if Transfer-Encoding is chunked" do
-      before :each do
-        init_input("hello", "TRANSFER_ENCODING" => "chunked")
-      end
-
-      it "reads exactly len bytes if available" do
-        @input.read(2).should == "he"
-        @input.read(2).should == "ll"
-      end
-
-      it "reads until EOF if less than len bytes are available" do
-        @input.read(2).should == "he"
-        @input.read(4).should == "llo"
-      end
-
-      it "returns nil if EOF is reached" do
-        @input.read(5).should == "hello"
-        @input.read(1).should be_nil
-      end
-    end
-
-    context "if neither Content-Length nor Transfer-Encoding chunked are given" do
-      it "returns nil" do
-        init_input("hello")
-        @input.read(2).should be_nil
-      end
-    end
-  end
-end
-
-shared_examples "TeeInput#size" do
-  context "if Content-Length is given" do
-    it "returns the value in Content-Length" do
-      init_input("hello world", "CONTENT_LENGTH" => 10)
-      @input.size.should == 10
-    end
-  end
-
-  context "if Transfer-Encoding is chunked" do
-    it "returns the number of bytes that can be read from the socket until EOF" do
-      init_input("hello world", "TRANSFER_ENCODING" => "chunked")
-      @input.size.should == 11
-    end
-  end
-
-  context "if neither Content-Length nor Transfer-Encoding chunked are given" do
-    it "returns 0" do
-      init_input("hello world")
-      @input.size.should == 0
-    end
-  end
-end
-
-describe Utils::TeeInput do
-  before :each do
-    @sock, @sock2 = UNIXSocket.pair
-  end
-
-  after :each do
-    [@sock, @sock2].each do |sock|
-      sock.close if sock && !sock.closed?
-    end
-    @input.close if @input
-  end
-
-  context "when unbuffered" do
-    def init_input(data, env = {})
-      @input = Utils::TeeInput.new(@sock2, env)
-      @sock.write(data)
-      @sock.close
-    end
-
-    describe("#gets") { include_examples "TeeInput#gets" }
-    describe("#read") { include_examples "TeeInput#read" }
-    describe("#size") { include_examples "TeeInput#size" }
-  end
-
-  context "when buffered" do
-    def init_input(data, env = {})
-      @input = Utils::TeeInput.new(@sock2, env)
-      @sock.write(data)
-      @sock.close
-      @input.read
-      @input.rewind
-    end
-
-    describe("#gets") { include_examples "TeeInput#gets" }
-    describe("#read") { include_examples "TeeInput#read" }
-    describe("#size") { include_examples "TeeInput#size" }
-  end
-end
-
-end # module PhusionPassenger