httparrot 0.0.1

data/spec/httparrot_config_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe HTTParrot::Config do 
+
+  context "defaults" do 
+    before(:each){ HTTParrot::Config.restore_defaults! }
+
+    specify{ HTTParrot::Config.Port.should eq(4000) }
+    specify{ HTTParrot::Config.SSLPort.should eq(4001) }
+    specify{ HTTParrot::Config.ssl.should be_true }
+    specify{ HTTParrot::Config.template_root.should be_nil }
+    specify{ HTTParrot::Config.verbose.should be_false }
+  end
+
+  context "updates" do
+    before(:each) { HTTParrot::Config.restore_defaults! }
+
+    it ":Port" do
+      HTTParrot::Config.Port = 5000
+      HTTParrot::Config.Port.should eq(5000)
+      HTTParrot::Config.config[:Port].should eq(5000)
+    end
+
+    it ":SSLPort" do
+      HTTParrot::Config.SSLPort = 5000
+      HTTParrot::Config.SSLPort.should eq(5000)
+      HTTParrot::Config.config[:SSLPort].should eq(5000)
+    end
+
+    it ":ssl" do
+      HTTParrot::Config.ssl = false 
+      HTTParrot::Config.ssl.should be_false 
+      HTTParrot::Config.config[:ssl].should be_false 
+    end
+
+    it ":verbose" do
+      HTTParrot::Config.verbose = true 
+      HTTParrot::Config.verbose.should be_true
+      HTTParrot::Config.config[:verbose].should be_true
+    end
+
+    it ":template_root" do
+      HTTParrot::Config.template_root = "updated value" 
+      HTTParrot::Config.template_root.should eq("updated value") 
+      HTTParrot::Config.config[:template_root].should eq("updated value") 
+    end
+
+  end
+
+end

data/spec/httparrot_spec.rb

@@ -0,0 +1,3 @@
+require 'spec_helper'
+
+

data/spec/response_factory_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe HTTParrot::ResponseFactory do 
+
+  context "API" do 
+    specify{ described_class.should respond_to(:clear!) }
+    specify{ described_class.should respond_to(:define) }
+    specify{ described_class.should respond_to(:build) }
+    specify{ described_class.should respond_to(:one_of) }
+    specify{ described_class.should respond_to(:collection_of) }
+  end
+
+  context "#clear!" do
+
+    it "removes all factories when cleared" do
+      HTTParrot::ResponseFactory.define(:response) { |r| r.test = "Test" }
+      HTTParrot::ResponseFactory.clear!
+      HTTParrot::ResponseFactory.instance_variable_get("@factory_classes").size.should eq(0)
+    end
+
+  end
+
+  context "#collection_of" do
+    before(:each) { HTTParrot::ResponseFactory.clear! }
+
+    it "requires the factory_class to exist" do 
+      expect{ HTTParrot::ResponseFactory.collection_of(:response, 10) }.to raise_error(/factory/)
+    end
+
+    it "returns the specified number of Widgets" do 
+      HTTParrot::ResponseFactory.define(:response) { |t| t.value = "Test" }
+      c = HTTParrot::ResponseFactory.collection_of(:response, 10)
+      c.size.should eq(10)
+    end
+
+    it "returns Widgets with values from factory definitions" do
+      HTTParrot::ResponseFactory.define(:response) { |t| t.value = "Test" }
+      c = HTTParrot::ResponseFactory.collection_of(:response, 10)
+      c.each do |w|
+        w.should be_a(HTTParrot::Widget)
+        w.value.should eq("Test")
+      end
+    end
+
+    it "returns Widgets with values from factory definitions overridden" do
+      HTTParrot::ResponseFactory.define(:response) { |t| t.value = "Test" }
+      c = HTTParrot::ResponseFactory.collection_of(:response, 10, :value => "Over")
+      c.each do |w|
+        w.should be_a(HTTParrot::Widget)
+        w.value.should eq("Over")
+      end
+    end
+
+  end
+
+  context "#define" do 
+    before(:each) { HTTParrot::ResponseFactory.clear! }
+
+    it "adds a factory to the factories available" do
+      HTTParrot::ResponseFactory.define(:response) { |r| r.test = "Test" }
+      HTTParrot::ResponseFactory.instance_variable_get("@factory_classes").size.should eq(1)
+    end
+
+    it "overwrites a factory with the same name" do
+      HTTParrot::ResponseFactory.should_receive(:warn).with(/redefinition/)
+      HTTParrot::ResponseFactory.define(:response) { |r| r.test = "Test1" }
+      HTTParrot::ResponseFactory.define(:response) { |r| r.test = "Test2" }
+      HTTParrot::ResponseFactory.instance_variable_get("@factory_classes").size.should eq(1)
+    end
+
+    it "warns when a factory is overwritten" do
+      HTTParrot::ResponseFactory.should_receive(:warn).with(/redefinition/)
+      HTTParrot::ResponseFactory.define(:response) { |r| r.test = "Test1" }
+      HTTParrot::ResponseFactory.define(:response) { |r| r.test = "Test2" }
+    end
+
+    it "requires a block to be sent during definition" do 
+      lambda{ HTTParrot::ResponseFactory.define(:response) }.should raise_error(/block/)
+    end
+
+    it "requires a factory name to be included" do 
+      lambda{ HTTParrot::ResponseFactory.define { nil } }.should raise_error(/arguments/)
+    end
+
+  end
+
+  context "#one_of" do
+
+    it "warns if choices are not provided" do
+      HTTParrot::ResponseFactory.should_receive(:warn).with(/choices/)
+      HTTParrot::ResponseFactory.one_of([])
+    end
+
+    it "returns a choice" do 
+      choices = [1, 2, 3, 4, 5]
+      choices.should include(HTTParrot::ResponseFactory.one_of(choices))
+      choices = ["choice1", "choice2", "choice3"]
+      choices.should include(HTTParrot::ResponseFactory.one_of(choices))
+    end
+
+  end
+
+  context "#build" do
+    before(:each) { HTTParrot::ResponseFactory.clear! }
+
+    it "raises error if factory does not exist" do 
+      expect{ HTTParrot::ResponseFactory.build(:response) }.to raise_error(/factory type/)
+    end
+
+    it "calls the definition block during build" do 
+      HTTParrot::ResponseFactory.define(:response) { |r| raise "block call" }
+      expect{ HTTParrot::ResponseFactory.build(:response) }.to raise_error(/block call/)
+    end
+
+    it "returns a response with values set from definition" do 
+      HTTParrot::ResponseFactory.define(:response) { |r| r.value = "Test1" }
+      res = HTTParrot::ResponseFactory.build(:response)
+      res.value.should eq("Test1")
+    end
+
+    it "returns a Widget" do 
+      HTTParrot::ResponseFactory.define(:response) { |r| r.value = "Test1" }
+      res = HTTParrot::ResponseFactory.build(:response)
+      res.should be_a(HTTParrot::Widget)
+    end
+
+    it "overrides defaults when changes are provided in build" do 
+      HTTParrot::ResponseFactory.define(:response) { |r| r.value = "Test1" }
+      res = HTTParrot::ResponseFactory.build(:response, :value => "New Val")
+      res.value.should eq("New Val")
+    end
+
+  end
+  
+end

data/spec/server_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+require 'net/http'
+
+describe HTTParrot::Server do
+
+  before(:all) do 
+    @server = HTTParrot::Server.new
+    @server.start
+  end
+
+  after(:all) do 
+    @server.stop
+  end
+
+  context "API" do 
+    specify{ @server.should respond_to(:start) }
+    specify{ @server.should respond_to(:stop) }
+    specify{ @server.should respond_to(:running?) }
+    specify{ @server.should respond_to(:started?) }
+    specify{ @server.should respond_to(:clear!) }
+    specify{ @server.should respond_to(:reset_counts) }
+    specify{ @server.should respond_to(:call) }
+    specify{ @server.should respond_to(:register) }
+  end 
+
+  specify{ @server.running?.should be_true } 
+  specify{ @server.started?.should be_true }
+
+  context "#initialize" do 
+
+    it "uses HTTParrot::Content defaults (by default)" do 
+      current = described_class.new
+      current.options.should include(HTTParrot::Config.config)
+    end
+
+    it "allows overrides from passed options" do 
+      current = described_class.new(:Port => 6000)
+      current.options[:Port].should eq(6000)
+    end
+
+  end
+
+  context "#clear!" do 
+    before(:each) do 
+      HTTParrot::ResponseFactory.clear!
+      HTTParrot::Config.config[:template_root] = File.dirname(__FILE__)
+      HTTParrot::ResponseFactory.define(:widget) { |r| r.widget_header = "SERVER" }
+    end
+
+    it "resets all handlers" do
+      handlers = @server.instance_variable_get("@call_handlers")
+      handlers.each_value {|v| v.should be_empty }
+      widget = HTTParrot::ResponseFactory.build(:widget)
+      @server.register(:get, lambda{ |v| v =~ /widget/ }, widget.to_rack)
+      @server.clear!
+      handlers = @server.instance_variable_get("@call_handlers")
+      handlers.each_value {|v| v.should be_empty }
+    end
+
+  end
+
+  describe "counts and call handlers" do
+    before(:each) do 
+      HTTParrot::ResponseFactory.clear!
+      HTTParrot::Config.config[:template_root] = File.dirname(__FILE__)
+      HTTParrot::ResponseFactory.define(:widget) { |r| r.widget_header = "SERVER" }
+      @widget = HTTParrot::ResponseFactory.build(:widget)
+      @server.clear!
+    end
+
+    context "call_handlers" do 
+      before(:each) do
+        @widget_handler = @server.register(:post, lambda{ |v| v =~ /widget/ }, @widget.to_rack)
+        http_request = Net::HTTP.new("127.0.0.1", HTTParrot::Config.Port)
+        http_request.post("/widget", "widget=widget")
+      end
+
+      it "counts calls" do
+        @widget_handler.response_count.should eq(1)
+      end
+
+      it "resets counts" do 
+        @server.reset_counts
+        @widget_handler.response_count.should eq(0)
+      end
+
+    end
+
+    context "regex_handlers" do
+      before(:each) do 
+        @widget_handler = @server.register(:post, /widget/, @widget.to_rack)
+        http_request = Net::HTTP.new("127.0.0.1", HTTParrot::Config.Port)
+        http_request.post("/widget", "widget=widget")
+      end
+
+      it "counts calls" do
+        @widget_handler.response_count.should eq(1)
+      end
+
+      it "resets counts" do 
+        @server.reset_counts
+        @widget_handler.response_count.should eq(0)
+      end
+
+    end
+
+    context "endpoint_handlers" do 
+      before(:each) do
+        @widget_handler = @server.register(:post, "widget", @widget.to_rack)
+        http_request = Net::HTTP.new("127.0.0.1", HTTParrot::Config.Port)
+        http_request.post("/widget", "widget=widget")
+      end
+
+      it "counts calls" do
+        @widget_handler.response_count.should eq(1)
+      end
+
+      it "resets counts" do 
+        @server.reset_counts
+        @widget_handler.response_count.should eq(0)
+      end
+
+    end
+
+    context "complex_handlers" do 
+      before(:each) do 
+        @widget_handler = @server.register(:post, ["widget", /widget/], @widget.to_rack)
+        http_request = Net::HTTP.new("127.0.0.1", HTTParrot::Config.Port)
+        http_request.post("/widget", "widget=widget")
+      end
+
+      it "counts calls" do
+        @widget_handler.response_count.should eq(1)
+      end
+
+      it "resets counts" do 
+        @server.reset_counts
+        @widget_handler.response_count.should eq(0)
+      end
+
+    end
+
+  end
+
+  context "#register" do
+    before(:each) do 
+      HTTParrot::ResponseFactory.clear!
+      HTTParrot::Config.config[:template_root] = File.dirname(__FILE__)
+      HTTParrot::ResponseFactory.define(:widget) { |r| r.widget_header = "SERVER" }
+      @widget = HTTParrot::ResponseFactory.build(:widget)
+      @server.clear!
+    end
+
+    it "registers call_handlers" do 
+      handlers = @server.instance_variable_get("@call_handlers")
+      handlers.each_value {|v| v.should be_empty }
+      @server.register(:get, lambda{ |v| v =~ /widget/ }, @widget.to_rack)
+      handlers[:get].should_not be_empty
+      handlers[:post].should be_empty
+    end
+
+    it "registers regex_handlers" do 
+      handlers = @server.instance_variable_get("@regex_handlers")
+      handlers.each_value {|v| v.should be_empty }
+      @server.register(:get, /widget/, @widget.to_rack)
+      handlers[:get].should_not be_empty
+      handlers[:post].should be_empty
+    end
+
+    it "registers endpoint_handlers" do 
+      handlers = @server.instance_variable_get("@endpoint_handlers")
+      handlers.each_value {|v| v.should be_empty }
+      @server.register(:get, "/widget", @widget.to_rack)
+      handlers[:get].should_not be_empty 
+      handlers[:post].should be_empty
+    end
+
+    it "registers complex_handlers" do 
+      handlers = @server.instance_variable_get("@complex_handlers")
+      handlers.each_value {|v| v.should be_empty }
+      @server.register(:get, ["/widget", /widget/], @widget.to_rack)
+      handlers[:get].should_not be_empty
+      handlers[:post].should be_empty
+    end
+
+    it "raises error when handler type cannot be inferred" do 
+      expect{ @server.register(:get, 1, @widget.to_rack) }.to raise_error(/callable/)
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :development, :test
+
+RSpec.configure do |c|
+  c.mock_with :rspec
+  c.formatter = "progress"
+  c.tty = true if defined?(JRUBY_VERSION)
+  c.color_enabled = true
+end
+
+$:.push File.expand_path('..', File.dirname(__FILE__))
+$:.push File.expand_path('../lib', File.dirname(__FILE__))
+require "httparrot"

data/spec/templates/awesometown_protocol.erb

@@ -0,0 +1,11 @@
+<% 
+  header["AWESOMEHEADER"] = awesome_header
+  header["ANOTHERONE"] = another_one
+  header["ANDONEMORE"] = and_one_more
+%>
+
+<SOMEML>
+<VAL1><%= val1 %></VAL1>
+<VAL2><%= val2 %></VAL2>
+<VAL3><%= val3 %></VAL3>
+</SOMEML>

data/spec/templates/widget.erb

@@ -0,0 +1,12 @@
+<%
+  header["this"] = "that"
+  header["that"] = "this"
+%>
+
+WIDGETHEADER: <%= widget_header %>
+
+<WIDGET>
+<VAL1><%= val1 %></VAL1>
+<VAL2><%= val2 %></VAL2>
+<VAL3><%= val3 %></VAL3>
+</WIDGET>

data/spec/widget_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+describe HTTParrot::Widget do
+
+  context "API" do 
+    specify{ subject.should respond_to(:rack_response) }
+    specify{ subject.should respond_to(:to_hash) }
+    specify{ subject.should respond_to(:to_rack) }
+    specify{ subject.should respond_to(:to_rack_response) }
+    specify{ subject.should respond_to(:parent) }
+    specify{ subject.should respond_to(:parent!) }
+  end
+
+  specify{ subject.to_hash.should be_a(Hash) }
+
+  shared_examples "a parental relationship" do |meth|
+
+    it "adds new values" do 
+      current = HTTParrot::Widget.new(:first => 1, :second => 2)
+      current.method(meth).call({:first => 2, :second => 1, :third => 3})
+      current.third.should eq(3)
+    end
+
+    it "raises error when not a symbol or respond_to? to_hash" do 
+      expect{ subject.method(meth).call([]) }.to raise_error(/symbol/) 
+    end
+
+    it "raises error when parent factory does not exist" do 
+      expect{ subject.method(meth).call(:something) }.to raise_error(/unknown factory/i)
+    end
+
+    it "builds corresponding factory when symbol" do 
+      HTTParrot::ResponseFactory.define(:response) { |r| r.value = "Test" }
+      current = HTTParrot::Widget.new
+      current.method(meth).call(:response)
+      current.value.should eq("Test")
+    end
+
+    it "adds values from multiple parents" do 
+      current = HTTParrot::Widget.new
+      current.method(meth).call(:first => 1)
+      current.method(meth).call(:second => 2)
+      current.method(meth).call(:third => 3)
+      current.first.should eq(1)
+      current.second.should eq(2)
+      current.third.should eq(3)
+    end
+
+  end
+
+  context "#parent" do
+    before(:each) { HTTParrot::ResponseFactory.clear! }
+
+    it_behaves_like "a parental relationship", :parent
+
+    it "does not overwrite existing values" do
+      current = HTTParrot::Widget.new(:first => 1, :second => 2)
+      current.parent({:first => 2, :second => 1})
+      current.first.should eq(1)
+      current.second.should eq(2)
+    end
+
+    it "respects parent call order for adding values" do 
+      current = HTTParrot::Widget.new
+      current.parent(:first => 1)
+      current.parent(:second => 2)
+      current.parent(:third => 3)
+      current.parent(:first => 2, :second => 3, :third => 1)
+      current.first.should eq(1)
+      current.second.should eq(2)
+      current.third.should eq(3)
+    end
+
+  end
+
+  context "#parent!" do 
+    before(:each) { HTTParrot::ResponseFactory.clear! }
+
+    it_behaves_like "a parental relationship", :parent!
+
+    it "overwrites existing values" do
+      current = HTTParrot::Widget.new(:first => 1, :second => 2)
+      current.parent!({:first => 2, :second => 1})
+      current.first.should eq(2)
+      current.second.should eq(1)
+    end
+
+    it "overwrites with last parent call for adding values" do 
+      current = HTTParrot::Widget.new
+      current.parent!(:first => 1)
+      current.parent!(:second => 2)
+      current.parent!(:third => 3)
+      current.parent!(:first => 2, :second => 3, :third => 1)
+      current.first.should eq(2)
+      current.second.should eq(3)
+      current.third.should eq(1)
+    end
+
+  end
+
+  context "#rack_response" do 
+    before(:each) { HTTParrot::Config.restore_defaults! }
+
+    it "returns a valid rack response" do 
+      current = described_class.new
+      HTTParrot::Config.config[:template_root] = File.dirname(__FILE__) + "/templates" 
+      current.rack_response.should be_a(Array)
+      current.rack_response.size.should eq(3)
+      current.rack_response.first.should be_a(Integer)
+      current.rack_response.last.should respond_to(:each)
+      current.rack_response[1].should be_a(Hash)
+    end
+
+  end
+
+  context "#to_s" do
+    before(:each) { HTTParrot::Config.restore_defaults! }
+
+    it "renders the file when full path is present in template_file" do 
+      current = described_class.new
+      current.template_file = File.expand_path("./templates/awesometown_protocol.erb",
+                                               File.dirname(__FILE__))
+
+      current.to_s
+      current.header.inspect.should match(/AWESOMEHEADER/i)
+    end
+
+    it "prioritizes template_file over HTTParrot::Config.template_root" do 
+      current = described_class.new
+      current.template_file = File.expand_path("./templates/awesometown_protocol.erb",
+                                               File.dirname(__FILE__))
+
+      current.to_s
+      current.header.inspect.should match(/AWESOMEHEADER/i)
+    end
+
+    context "rendering erb with current widget" do
+      before(:each) { HTTParrot::ResponseFactory.clear! }
+
+      it "inserts the value of defined methods into the output" do
+        current = described_class.new
+        current.widget_header = "TEST HEADER"
+        HTTParrot::Config.config[:template_root] = File.dirname(__FILE__) + "/templates" 
+        current.to_s.should match(/TEST HEADER/)
+      end
+
+      it "removes erb tags when value is not present" do 
+        current = described_class.new
+        HTTParrot::Config.config[:template_root] = File.dirname(__FILE__) + "/templates" 
+        current.to_s.should_not match(/widget_header/)
+      end
+
+    end
+
+    context "falls back to HTTParrot::Config[:template_root] when no template_file" do
+      before(:each) { HTTParrot::Config.restore_defaults! }
+
+      it "warn" do
+        current = described_class.new
+        bad_dir = File.expand_path("../lib/httparrot.rb", File.dirname(__FILE__))
+        HTTParrot::Config.config[:template_root] = File.dirname(bad_dir) 
+        warning = Regexp.escape(current.__send__(:template_root_search))
+        current.should_receive(:warn).with(/#{warning}/)
+        current.to_s
+      end
+
+      it "success" do
+        current = described_class.new
+        HTTParrot::Config.config[:template_root] = File.dirname(__FILE__) + "/templates" 
+        current.to_s.should match(/WIDGETHEADER/i)
+      end
+
+      it "success, handles trailing slash" do 
+        current = described_class.new
+        HTTParrot::Config.config[:template_root] = File.dirname(__FILE__) + "/templates/"
+        current.to_s.should match(/WIDGETHEADER/i)
+      end
+
+    end
+
+  end
+
+end