smg 0.2.1 → 0.2.2

data/spec/http_spec.rb

@@ -1,76 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,241 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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