smg 0.1.0 → 0.2.0

data/spec/http_spec.rb

@@ -0,0 +1,76 @@
+require File.expand_path File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe SMG::HTTP::Model, ".uri_for" do
+
+  before :all do
+    @klass = Class.new { include SMG::Resource, SMG::HTTP }
+    @klass.site "http://www.example.org"
+    @klass.params "developer" => "Valve"
+  end
+
+  it "appends a path to the base URI" do
+    uri = @klass.send(:uri_for, "search")
+    uri.host.should == "www.example.org"
+    uri.path.should == "/search"
+    uri.query_values.should == {"developer" => "Valve"}
+  end
+
+  it "appends a query to the base URI" do
+    uri = @klass.send(:uri_for, "search", {"cake" => "Lie"})
+    uri.host.should == "www.example.org"
+    uri.path.should == "/search"
+    uri.query_values.should == {"developer" => "Valve", "cake" => "Lie"}
+  end
+
+end
+
+describe SMG::HTTP::Model do
+
+  before :all do
+    @klass = Class.new { include SMG::Resource, SMG::HTTP }
+    @klass.site "http://www.example.org"
+    @klass.params "developer" => "Valve"
+    @klass.extract "game/name"
+  end
+
+  Hash[[:get, :post, :put, :delete, :head].zip(SMG::HTTP::Request::VERBS)].each do |sym,verb|
+    describe ".#{sym}" do
+
+      before :each do
+        @response = Net::HTTPOK.new('1.1', 200, "OK")
+        @response.stub!(:body).and_return("<game><name>Portal</name></game>")
+      end
+
+      before :each do
+        @request = mock('request')
+        @request.stub!(:perform).and_return(@response)
+      end
+
+      before :each do
+        @headers = {"Accept-Encoding" => "gzip,deflate;*;q=0"}
+        @options = {:query => {"cake" => "LIE"}, :headers => @headers}
+        SMG::HTTP::Request.should_receive(:new).
+        with(verb, instance_of(Addressable::URI), {:headers => @headers}).
+        and_return(@request)
+      end
+
+      it "performs #{sym.to_s.upcase} request" do
+        @klass.send(sym, "game", @options)
+      end
+
+      it "parses response' body when no block given" do
+        @game = @klass.send(sym, "game", @options)
+        @game.name.should == "Portal"
+      end
+
+      it "yields response and parses the block returning value when block given" do
+        @game = @klass.send(sym, "game", @options) { |response| "<game><name>Portal2</name></game>" }
+        @game.name.should == "Portal2"
+      end
+
+    end
+  end
+
+end
+
+# EOF

data/spec/lib/helpers/http_helpers.rb

@@ -0,0 +1,27 @@
+module Spec #:nodoc:
+  module Helpers #:nodoc:
+    module HTTPHelpers
+
+      def http(uri, proxy = nil)
+        @http ||= mock('http')
+        uri = Addressable::URI.parse(uri)
+        args = (proxy && p = Addressable::URI.parse(proxy)) ?
+          [uri.host, uri.port, p.host, p.port, p.user, p.password] :
+          [uri.host, uri.port]
+
+        Net::HTTP.should_receive(:new).with(*args).and_return(@http)
+      end
+
+      def stub_response(code, message, *args)
+        response = Net::HTTPResponse::CODE_TO_OBJ[code.to_s].new('1.1', code, message)
+        response.initialize_http_header(Hash === args.last ? args.pop : {})
+        response.stub!(:body).and_return(args.join) unless args.empty?
+        @http.should_receive(:request).and_return response
+        response
+      end
+
+    end
+  end
+end
+
+# EOF

data/spec/lib/matchers/instance_methods.rb

@@ -0,0 +1,38 @@
+module Spec #:nodoc:
+  module Matchers #:nodoc:
+
+    #http://github.com/rubyspec/mspec/blob/master/lib/mspec/matchers/have_instance_method.rb
+    class HaveInstanceMethodMatcher
+
+      def initialize(method, include_super)
+        @method = method.to_sym
+        @include_super = include_super
+      end
+
+      def matches?(mod)
+        @mod = mod
+        mod.instance_methods(@include_super).include?(@method) || 
+        mod.instance_methods(@include_super).include?(@method.to_s)
+      end
+
+      def failure_message
+        ["Expected #{@mod} to have instance method '#{@method.to_s}'",
+         "but it does not"]
+      end
+
+      def negative_failure_message
+        ["Expected #{@mod} NOT to have instance method '#{@method.to_s}'",
+         "but it does"]
+      end
+    end
+
+    module HaveInstanceMethodMixin
+      def have_instance_method(method, include_super=true)
+        HaveInstanceMethodMatcher.new method, include_super
+      end
+    end
+
+  end
+end
+
+# EOF

data/spec/mapping/element_spec.rb

@@ -0,0 +1,241 @@
+require File.expand_path File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe SMG::Mapping::Element do
+
+  describe "#initialize" do
+
+    it "respects path" do
+      e = SMG::Mapping::Element.new(['node','subnode'])
+      e.name.should == :subnode
+      e.accessor.should == :subnode=
+
+      e = SMG::Mapping::Element.new(['node','ns:subnode'])
+      e.name.should == :ns_subnode
+      e.accessor.should == :ns_subnode=
+
+      e = SMG::Mapping::Element.new(['node','subnode'], :nested => true)
+      e.name.should == :subnode
+      e.accessor.should == :subnode=
+
+      e = SMG::Mapping::Element.new(['node','ns:subnode'], :nested => true)
+      e.name.should == :ns_subnode
+      e.accessor.should == :ns_subnode=
+    end
+
+    it "respects namespaces" do
+    end
+
+    it "respects :at option" do
+      e = SMG::Mapping::Element.new(['node','subnode'], :at => :something)
+      e.name.should == :something
+      e.accessor.should == :something=
+
+      e = SMG::Mapping::Element.new(['node','ns:subnode'], :at => :something)
+      e.name.should == :something
+      e.accessor.should == :something=
+
+      e = SMG::Mapping::Element.new(['node','subnode'], :at => :something, :nested => true)
+      e.name.should == :something
+      e.accessor.should == :something=
+
+      e = SMG::Mapping::Element.new(['node','ns:subnode'], :at => :something, :nested => true)
+      e.name.should == :something
+      e.accessor.should == :something=
+    end
+
+    it "respects :as option" do
+      e = SMG::Mapping::Element.new(['node','subnode'], :at => :whatever, :as => :something)
+      e.name.should == :something
+      e.accessor.should == :something=
+
+      e = SMG::Mapping::Element.new(['node','ns:subnode'], :at => :whatever, :as => :something)
+      e.name.should == :something
+      e.accessor.should == :something=
+
+      e = SMG::Mapping::Element.new(['node','subnode'], :as => :whatever, :nested => true)
+      e.name.should == :whatever
+      e.accessor.should == :whatever=
+
+      e = SMG::Mapping::Element.new(['node','ns:subnode'], :as => :whatever, :nested => true)
+      e.name.should == :whatever
+      e.accessor.should == :whatever=
+    end
+
+    it "respects :collection option" do
+      e = SMG::Mapping::Element.new(['node','subnodes'], :collection => true)
+      e.name.should == :subnodes
+      e.accessor.should == :append_to_subnodes
+
+      e = SMG::Mapping::Element.new(['node','ns:subnodes'], :collection => true)
+      e.name.should == :ns_subnodes
+      e.accessor.should == :append_to_ns_subnodes
+
+      e = SMG::Mapping::Element.new(['node','subnodes'], :at => :something, :collection => true)
+      e.name.should == :something
+      e.accessor.should == :append_to_something
+
+      e = SMG::Mapping::Element.new(['node','ns:subnodes'], :at => :something, :collection => true)
+      e.name.should == :something
+      e.accessor.should == :append_to_something
+
+      e = SMG::Mapping::Element.new(['node','subnodes'], :at => :whatever, :as => :something, :collection => true)
+      e.name.should == :something
+      e.accessor.should == :append_to_something
+
+      e = SMG::Mapping::Element.new(['node','ns:subnodes'], :at => :whatever, :as => :something, :collection => true)
+      e.name.should == :something
+      e.accessor.should == :append_to_something
+
+      e = SMG::Mapping::Element.new(['node','subnodes'], :as => :something, :collection => true)
+      e.name.should == :something
+      e.accessor.should == :append_to_something
+
+      e = SMG::Mapping::Element.new(['node','ns:subnodes'], :as => :something, :collection => true)
+      e.name.should == :something
+      e.accessor.should == :append_to_something
+    end
+
+    it "defaults @context to nil" do
+      e = SMG::Mapping::Element.new(['node','subnode'])
+      e.context.should be_nil
+    end
+
+    describe "with :class option" do
+
+      it "defines the @data_class if :class is an SMG::Model" do
+        klass = Class.new { include SMG::Resource }
+        e = SMG::Mapping::Element.new(['node'], :class => klass)
+        e.data_class.should == klass
+      end
+
+      it "defines the @cast_to if :class is a valid typecast" do
+        klass = Class.new { include SMG::Resource }
+        e = SMG::Mapping::Element.new(['node'], :class => :string)
+        e.cast_to.should == :string
+      end
+
+      it "raises an ArgumentError otherwise" do
+        lambda { SMG::Mapping::Element.new(['node'], :class => "bogus!")}.
+        should raise_error ArgumentError, %r{should be an SMG::Model or a valid typecast}
+      end
+
+    end
+
+    describe "with :context option" do
+
+      it "defaults @context to nil, if :context is an empty Array" do
+        e = SMG::Mapping::Element.new(['node'], :context => [])
+        e.context.should be_nil
+      end
+
+      it "removes duplicates from @context" do
+
+        e = SMG::Mapping::Element.new(['node'], :context => [:foo, :bar, :baz])
+        e.context.should == [:foo, :bar, :baz]
+
+        e = SMG::Mapping::Element.new(['node'], :context => [:foo, :bar, :foo, :bar, :baz, :baz])
+        e.context.should == [:foo, :bar, :baz]
+
+        # undestructive
+        cct = [:foo, :foo, :bar]
+        e = SMG::Mapping::Element.new(['node','subnode'], :context => cct)
+        cct.should == [:foo, :foo, :bar]
+
+      end
+
+      it "raises an ArgumentError, if :context is not an Array of Symbols" do
+        lambda { e = SMG::Mapping::Element.new(['node'], :context => "something") }.
+        should raise_error ArgumentError, %r{should be an Array of Symbols}
+
+        lambda { e = SMG::Mapping::Element.new(['node'], :context => [42]) }.
+        should raise_error ArgumentError, %r{should be an Array of Symbols}
+      end
+
+    end
+
+  end
+
+  describe "#collection?" do
+
+    it "returns true if Element is a collection" do
+      e = SMG::Mapping::Element.new(['node','subnode'], :collection => true)
+      e.should be_a_collection
+    end
+
+    it "returns false otherwise" do
+      e = SMG::Mapping::Element.new(['node','subnode'])
+      e.should_not be_a_collection
+    end
+
+  end
+
+  describe "#cast" do
+
+    it "does nothing if there's no @cast_to" do
+      e = SMG::Mapping::Element.new(['node'])
+      thing = "42"
+      e.cast(thing).should be_eql thing
+    end
+
+    it "performs the typecast otherwise" do
+      e = SMG::Mapping::Element.new(['node'], :class => :integer)
+      thing = "42"
+      SMG::Mapping::TypeCasts.should_receive(:[]).with(:integer, thing).and_return("42 (typecasted)")
+      e.cast(thing).should == "42 (typecasted)"
+    end
+
+    it "raises an ArgumentError if typecasting fails" do
+      e = SMG::Mapping::Element.new(['node'], :class => :datetime)
+      lambda { e.cast('42') }.
+      should raise_error ArgumentError, %r{"42" is not a valid source for :datetime}
+    end
+
+  end
+
+  describe "#in_context_of?" do
+
+    it "returns true if @context of an Element is a nil" do
+      e = SMG::Mapping::Element.new(['node','subnode'])
+      e.context.should == nil
+      e.in_context_of?(:whatever).should == true
+    end
+
+    it "returns true if @context of an Element includes context" do
+      e = SMG::Mapping::Element.new(['node','subnode'], :context => [:foo])
+      e.context.should == [:foo]
+      e.in_context_of?(:foo).should == true
+    end
+
+    it "returns false otherwise" do
+      e = SMG::Mapping::Element.new(['node','subnode'], :context => [:foo])
+      e.context.should == [:foo]
+      e.in_context_of?(:bar).should == false
+    end
+
+  end
+
+  describe "#with?" do
+
+    it "returns true if the Hash passed contains @with" do
+      e = SMG::Mapping::Element.new(['node'], :with => {"id" => "3", "status" => "accepted"})
+      e.should be_with("id" => "3", "status" => "accepted")
+      e.should be_with("id" => "3", "status" => "accepted", "key" => "value")
+    end
+
+    it "returns true if there are no @with conditions" do
+      e = SMG::Mapping::Element.new(['node','subnode'])
+      e.with.should == nil
+      e.should be_with("key" => "value")
+    end
+
+    it "returns false otherwise" do
+      e = SMG::Mapping::Element.new(['node'], :with => {"id" => "3", "status" => "accepted"})
+      e.should_not be_with("status" => "accepted")
+      e.should_not be_with({})
+    end
+
+  end
+
+end
+
+# EOF

data/spec/mapping/typecasts_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe SMG::Mapping::TypeCasts, "[]" do
+
+  it "raises an ArgumentError when typecast is unknown" do
+    lambda { SMG::Mapping::TypeCasts[:bogus, "42"] }.should raise_error ArgumentError, %r{Can't typecast to :bogus}
+  end
+
+  it "is able to typecast (Stringable) into Fixnum" do
+    SMG::Mapping::TypeCasts[:integer, "42"].should == 42
+    SMG::Mapping::TypeCasts[:integer, nil ].should == 0
+  end
+
+  it "is able to typecast (Stringable) into Symbol" do
+    SMG::Mapping::TypeCasts[:symbol, "something"].should == :something
+  end
+
+  it "is able to typecast (Stringable) into Time" do
+    source = 'Thu Apr 15 18:16:23 +0400 2010'
+    value = SMG::Mapping::TypeCasts[:datetime, source]
+    value.should == Time.parse(source)
+  end
+
+  it "is able to typecast (Stringable) into Date" do
+    source = 'Thu Apr 15 18:16:23 +0400 2010'
+    value = SMG::Mapping::TypeCasts[:date, source]
+    value.should == Date.parse(source)
+  end
+
+  it "is able to typecast (Stringable) into URI" do
+    source = "http://example.org:4567/foo?bar=baz"
+    value = SMG::Mapping::TypeCasts[:uri, source]
+    value.should == URI.parse(source)
+  end
+
+  it "is able to typecast (Stringable) into Float" do
+    SMG::Mapping::TypeCasts[  :float  , nil   ].should == 0.00
+    SMG::Mapping::TypeCasts[  :float  , "42." ].should == 42.00
+    SMG::Mapping::TypeCasts[  :float  , ".42" ].should == 0.42
+    SMG::Mapping::TypeCasts[  :float  , "42"  ].should == 42.00
+  end
+
+  it "is able to typecast (Stringable) into Boolean" do
+    SMG::Mapping::TypeCasts[  :boolean  , nil         ].should == nil
+    SMG::Mapping::TypeCasts[  :boolean  , "true"      ].should == true
+    SMG::Mapping::TypeCasts[  :boolean  , "something" ].should == true
+    SMG::Mapping::TypeCasts[  :boolean  , "false"     ].should == false
+  end
+
+end
+
+# EOF

data/spec/resource_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe SMG::Resource do
+
+  before :each do
+    @klass = Class.new { include SMG::Resource }
+  end
+
+  describe "when included" do
+
+    it "extends class with the SMG::Model" do
+      @klass.should be_an SMG::Model
+    end
+
+  end
+
+  describe "#parsed!" do
+
+    it "marks resource as parsed" do
+      resource = @klass.new
+      resource.should_not be_parsed
+      resource.parsed!
+      resource.should be_parsed
+    end
+
+  end
+
+end
+
+# EOF