gopher2000 0.1.0

data/spec/rendering/menu_spec.rb

@@ -0,0 +1,109 @@
+require File.join(File.dirname(__FILE__), '/../spec_helper')
+
+describe Gopher::Rendering::Menu do
+  before(:each) do
+    @app = Gopher::Application.new
+    @app.reset!
+    @app.config[:host] = "host"
+    @app.config[:port] = 1234
+
+    @ctx = Gopher::Rendering::Menu.new(@app)
+  end
+
+  it 'should add text as a gopher line' do
+    @ctx.text("gopher forever")
+    @ctx.result.should == "igopher forever\tnull\t(FALSE)\t0\r\n"
+  end
+
+  describe "sanitize_text" do
+    it "should remove extra whitespace from end of line" do
+      @ctx.sanitize_text("x   ").should == "x"
+    end
+
+    it "should convert tabs to spaces" do
+      @ctx.sanitize_text("x\tx").should == "x        x"
+    end
+
+    it "should remove newlines" do
+      @ctx.sanitize_text("x\nx").should == "xx"
+    end
+  end
+
+  describe "line" do
+    it "should work" do
+      @ctx.line("type", "text", "selector", "host", "port").should == "typetext\tselector\thost\tport\r\n"
+    end
+
+    it "should use application host/port as defaults" do
+      @ctx.line("type", "text", "selector").should == "typetext\tselector\thost\t1234\r\n"
+    end
+  end
+
+  describe "error" do
+    it "should call text with right selector" do
+      @ctx.should_receive(:text).with("foo", '3')
+      @ctx.error("foo")
+    end
+  end
+
+  describe "directory" do
+    it "should call link with right selector" do
+      @ctx.should_receive(:line).with("1", "foo", "/bar/foo", nil, nil)
+      @ctx.directory("foo", "/bar/foo")
+    end
+  end
+
+  describe "link" do
+    it "should get type with determine_type" do
+      @ctx.should_receive(:determine_type).with("foo.txt").and_return("A")
+      @ctx.link("FILE", "foo.txt").should == "AFILE\tfoo.txt\thost\t1234\r\n"
+    end
+  end
+
+  describe "search" do
+    it "should output link type/text" do
+      @ctx.search("FIND", "search").should == "7FIND\tsearch\thost\t1234\r\n"
+    end
+  end
+
+  describe "menu" do
+    it "should output link type/text" do
+      @ctx.menu("MENU ITEM", "item").should == "1MENU ITEM\titem\thost\t1234\r\n"
+    end
+  end
+
+  describe "br" do
+    it "should generate an empty text line" do
+      @ctx.should_receive(:text).with("i", "")
+      @ctx.br
+    end
+
+    it "should call #text multiple times" do
+      @ctx.should_receive(:text).twice.with("i", "")
+      @ctx.br(2)
+    end
+
+    it "should output an empty menu item" do
+      @ctx.br
+      @ctx.result.should == "i\tnull\t(FALSE)\t0\r\n"
+    end
+  end
+
+  context "determine_type" do
+    {
+      "foo.zip" => '5',
+      "foo.gz" => '5',
+      "foo.bz2" => '5',
+      "foo.gif" => 'g',
+      "foo.jpg" => 'I',
+      "foo.png" => 'I',
+      "foo.mp3" => 's',
+      "foo.wav" => 's',
+      "foo.random-file" => "0"
+    }.each do |file, expected|
+      it "should have right selector for #{file}" do
+        @ctx.determine_type(file).should == expected
+      end
+    end
+  end
+end

data/spec/rendering_spec.rb

@@ -0,0 +1,84 @@
+require File.join(File.dirname(__FILE__), '/spec_helper')
+
+class MockServer < Gopher::Application
+  attr_accessor :menus, :text_templates, :params, :request
+
+  def initialize
+    @menus = {}
+    @text_templates = {}
+  end
+end
+
+
+describe Gopher::Application do
+  before(:each) do
+    @s = MockServer.new
+  end
+
+  describe "find_template" do
+    it "should check in menus" do
+      @s.menus['foo'] = "bar"
+      @s.find_template('foo').should == ["bar", Gopher::Rendering::Menu]
+    end
+    it "should check in text_templates" do
+      @s.text_templates['foo'] = "bar"
+      @s.find_template('foo').should == ["bar", Gopher::Rendering::Text]
+    end
+  end
+
+  describe "render" do
+    it "should raise error if no such template" do
+      expect{@s.render('xyzzy')}.to raise_error(Gopher::TemplateNotFound)
+    end
+
+    it "has access to params obj" do
+      @s.params = "xyz"
+      @s.menu :foo do
+        @params
+      end
+
+      @s.render(:foo).should == "xyz"
+    end
+
+    it "has access to request obj" do
+      @s.request = "abc"
+      @s.menu :foo do
+        @request
+      end
+
+      @s.render(:foo).should == "abc"
+    end
+
+    it "rendering text access to request obj" do
+      @s.request = "abc"
+      @s.text :foo do
+        @request
+      end
+
+      @s.render(:foo).should == "abc"
+    end
+  end
+
+  describe "not_found_template" do
+    before(:each) do
+      @s.reset!
+    end
+
+    it "should use custom template if provided" do
+      @s.not_found do ; end
+      @s.not_found_template.should == :not_found
+    end
+
+    it "should use default otherwise" do
+      @s.not_found_template.should == :'internal/not_found'
+    end
+  end
+
+  # describe "register_defaults" do
+  #   it "should add to internal" do
+  #     @s.find_template(:'internal/not_found').should be_nil
+  #     @s.register_defaults
+  #     @s.find_template(:'internal/not_found').should_not be_nil
+  #   end
+  # end
+end

data/spec/request_spec.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), '/spec_helper')
+
+describe Gopher::Request do
+  it 'should split raw request' do
+    request = Gopher::Request.new("foo\tbar")
+    request.selector.should == "foo"
+    request.input.should == "bar"
+  end
+
+  it "should be ok with just selector" do
+    request = Gopher::Request.new("foo")
+    request.selector.should == "foo"
+    request.input.should == nil
+  end
+
+  it "should accept ip_address" do
+    request = Gopher::Request.new("foo", "bar")
+    request.ip_address.should == "bar"
+  end
+
+  it "valid? == true for valid selectors" do
+    request = Gopher::Request.new("x" * 255, "bar")
+    request.valid?.should == true
+  end
+
+  it "valid? == false for invalid selectors" do
+    request = Gopher::Request.new("x" * 256, "bar")
+    request.valid?.should == false
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), '/spec_helper')
+require 'tempfile'
+
+describe Gopher::Response do
+  before(:each) do
+    @response = Gopher::Response.new
+  end
+
+  it "gets size for string results" do
+    @response.body = "hi"
+    @response.size.should == 2
+  end
+
+  it "gets size for stringio results" do
+    @response.body = StringIO.new("12345")
+    @response.size.should == 5
+  end
+
+  it "defaults to 0 size for weird objects" do
+    @response.body = mock(Object)
+    @response.size.should == 0
+  end
+
+
+  it "gets size for file results" do
+    temp_file = Tempfile.new('result')
+    temp_file.write("1234567890")
+    temp_file.flush
+
+    @response.body = File.new(temp_file.path)
+    @response.size.should == 10
+  end
+end

data/spec/routing_spec.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__), '/spec_helper')
+
+class MockServer < Gopher::Application
+#  attr_accessor :routes
+#  include Gopher::Routing
+end
+
+describe Gopher::Application do
+  before(:each) do
+    @router = MockServer.new
+  end
+
+  describe "default_route" do
+    it "should set route as default" do
+      @router.default_route do
+        "hi"
+      end
+      junk, block = @router.lookup("sfssfdfsfsd")
+      block.class.should eql(UnboundMethod)
+    end
+  end
+
+  describe "globify" do
+    it "should add glob if none yet" do
+      @router.globify("/foo").should == "/foo/?*"
+    end
+
+    it "should be ok with trailing slashes" do
+      @router.globify("/foo/").should == "/foo/?*"
+    end
+
+    it "shouldn't add glob if there is one already" do
+      @router.globify("/foo/*").should == "/foo/*"
+    end
+  end
+
+  describe "mount" do
+    before(:each) do
+      @h = mock(Gopher::Handlers::DirectoryHandler)
+      @h.should_receive(:application=).with(@router)
+
+      Gopher::Handlers::DirectoryHandler.should_receive(:new).with({:bar => :baz, :mount_point => "/foo"}).and_return(@h)
+    end
+
+    it "should work" do
+      @router.mount("/foo", :bar => :baz)
+    end
+  end
+
+  describe "compile" do
+    it "should generate a basic string for routes without keys" do
+      lookup, keys, block = @router.compile! "/foo" do; end
+      lookup.to_s.should == /^\/foo$/.to_s
+      keys.should == []
+    end
+
+    context "with keys" do
+      it "should generate a lookup and keys for routes with keys" do
+        lookup, keys, block = @router.compile! "/foo/:bar" do; end
+        lookup.to_s.should == "(?-mix:^\\/foo\\/([^\\/?#]+)$)"
+
+        keys.should == ["bar"]
+      end
+
+      it "should match correctly" do
+        lookup, keys, block = @router.compile! "/foo/:bar" do; end
+        lookup.to_s.should == "(?-mix:^\\/foo\\/([^\\/?#]+)$)"
+
+        lookup.match("/foo/baz").should_not be_nil
+        lookup.match("/foo2/baz").should be_nil
+        lookup.match("/baz/foo/baz").should be_nil
+        lookup.match("/foo/baz/bar").should be_nil
+      end
+    end
+
+    context "with splat" do
+      it "should work with splats" do
+        lookup, keys, block = @router.compile! "/foo/*" do; end
+        lookup.to_s.should == "(?-mix:^\\/foo\\/(.*?)$)"
+        keys.should == ["splat"]
+      end
+
+      it "should match correctly" do
+        lookup, keys, block = @router.compile! "/foo/*" do; end
+
+        lookup.match("/foo/baz/bar/bam").should_not be_nil
+        lookup.match("/foo2/baz").should be_nil
+        lookup.match("/baz/foo/baz").should be_nil
+      end
+    end
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,127 @@
+require File.join(File.dirname(__FILE__), '/spec_helper')
+require 'tempfile'
+
+if ENV["WITH_SERVER_SPECS"].to_i == 1
+
+  class FakeApp < Gopher::Application
+    attr_accessor :fake_response
+    def dispatch(x)
+      @fake_response
+    end
+  end
+
+  describe Gopher::Server do
+    before(:each) do
+      @application = FakeApp.new
+      @application.scripts = []
+      @application.reset!
+
+      @host = "0.0.0.0"
+      @port = 12345
+
+      @application.config[:host] = @host
+      @application.config[:port] = @port
+
+      @request = Gopher::Request.new("foo", "bar")
+
+      @response = Gopher::Response.new(@request)
+      @response.code = :success
+      @response.body = "hi"
+    end
+
+    it "should work in non-blocking mode" do
+      @application.fake_response = @response
+      @application.stub!(:non_blocking?).and_return(false)
+
+      ::EM.run {
+        server = Gopher::Server.new(@application)
+        server.run!
+
+        # opens the socket client connection
+        socket = ::EM.connect(@host, @port, FakeSocketClient)
+        socket.send_data("123\n")
+
+        socket.onopen = lambda {
+          socket.data.last.chomp.should == "hi\r\n."
+          EM.stop
+        }
+      }
+    end
+
+    it "should handle Gopher::Response results" do
+      @application.fake_response = @response
+
+      ::EM.run {
+        server = Gopher::Server.new(@application)
+        server.run!
+
+        # opens the socket client connection
+        socket = ::EM.connect(@host, @port, FakeSocketClient)
+        socket.send_data("123\n")
+
+        socket.onopen = lambda {
+          socket.data.last.chomp.should == "hi\r\n."
+          EM.stop
+        }
+      }
+    end
+
+    it "should handle string results" do
+      @application.fake_response = @response
+
+      ::EM.run {
+        server = Gopher::Server.new(@application)
+        server.run!
+
+        # opens the socket client connection
+        socket = ::EM.connect(@host, @port, FakeSocketClient)
+        socket.send_data("123\n")
+
+        socket.onopen = lambda {
+          socket.data.last.chomp.should == "hi\r\n."
+          EM.stop
+        }
+      }
+    end
+
+    it "should handle File results" do
+      file = Tempfile.new('foo')
+      file.write("hi")
+      file.close
+
+      @application.fake_response = File.new(file)
+
+      ::EM.run {
+        server = Gopher::Server.new(@application)
+        server.run!
+
+        # opens the socket client connection
+        socket = ::EM.connect(@host, @port, FakeSocketClient)
+        socket.send_data("123\n")
+
+        socket.onopen = lambda {
+          socket.data.last.chomp.should == "hi"
+          EM.stop
+        }
+      }
+    end
+
+    it "should handle StringIO results" do
+      @application.fake_response = StringIO.new("hi")
+
+      ::EM.run {
+        server = Gopher::Server.new(@application)
+        server.run!
+
+        # opens the socket client connection
+        socket = ::EM.connect(@host, @port, FakeSocketClient)
+        socket.send_data("123\n")
+
+        socket.onopen = lambda {
+          socket.data.last.chomp.should == "hi\r\n."
+          EM.stop
+        }
+      }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,52 @@
+ENV['gopher_test'] = "1"
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+require 'bundler/setup'
+Bundler.require
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+
+require 'eventmachine'
+
+#
+# http://www.rosskaff.com/2010/12/behavior-driven-event-driven-eventmachine-rspec/
+#
+class FakeSocketClient < EventMachine::Connection
+
+  attr_writer :onopen, :onclose, :onmessage
+  attr_reader :data
+
+  def initialize
+    super
+
+    @state = :new
+    @data = []
+  end
+
+  def receive_data(data)
+    #puts "RECV: #{data}"
+    @data << data
+    if @state == :new
+      @onopen.call if @onopen
+      @state = :open
+    else
+      @onmessage.call(data) if @onmessage
+    end
+  end
+
+  def unbind
+    @onclose.call if @onclose
+  end
+end
+
+
+class FakeSocketServer < FakeSocketClient
+  attr_accessor :application
+end

data/specs.watchr

@@ -0,0 +1,60 @@
+# Run me with:
+#
+# $ watchr specs.watchr
+
+# --------------------------------------------------
+# Convenience Methods
+# --------------------------------------------------
+def all_spec_files
+  Dir['spec/**/*_spec.rb']
+end
+
+def run_spec_matching(thing_to_match)
+	puts "run #{thing_to_match}"
+  matches = all_spec_files.grep(/#{thing_to_match}/i)
+  if matches.empty?
+    puts "Sorry, thanks for playing, but there were no matches for #{thing_to_match}"
+  else
+    run matches.join(' ')
+  end
+end
+
+def run(files_to_run)
+  puts("Running: #{files_to_run}")
+  system("clear;rspec -cfs #{files_to_run}")
+  no_int_for_you
+end
+
+def run_all_specs
+  run(all_spec_files.join(' '))
+end
+
+# --------------------------------------------------
+# Watchr Rules
+# --------------------------------------------------
+watch('^spec/(.*)_spec\.rb')  { |m| run_spec_matching(m[1]) }
+watch("^lib/gopher2000/(.*)\.rb") { |m| run_all_specs }
+
+watch('^spec/spec_helper\.rb') { run_all_spec }
+
+# --------------------------------------------------
+# Signal Handling
+# --------------------------------------------------
+
+def no_int_for_you
+  @sent_an_int = nil
+end
+
+Signal.trap 'INT' do
+  if @sent_an_int then
+    puts " A second INT? Ok, I get the message. Shutting down now."
+    exit
+  else
+    puts " Did you just send me an INT? Ugh. I'll quit for real if you do it again."
+    @sent_an_int = true
+    Kernel.sleep 1.5
+    run_all_specs
+  end
+end
+
+run_all_specs