roar 0.0.1.alpha1 → 0.8.0

data/test/representable_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+require 'roar/model/representable'
+
+class RepresentableTest < MiniTest::Spec
+  
+  class ThisAsAppXml < Roar::Representer::Base
+    def self.deserialize(represented_class, mime_type, data)
+      "#{represented_class.name}->#{mime_type}: #{data}"
+    end
+    
+    def serialize(represented, mime_type)
+      "#{represented.class.name}->#{mime_type}"
+    end
+  end
+  
+  describe "Representable" do
+    before do
+      @c = Class.new do
+        include Roar::Model::Representable
+        
+        represents "application/xml", :with => ThisAsAppXml
+      end
+    end
+    
+    
+    describe ".representer_class_for" do
+      it "returns the class" do
+        assert_equal ThisAsAppXml, @c.representer_class_for("application/xml")
+      end
+      
+      it "returns nil if unknown" do
+        assert_equal nil, @c.representer_class_for("text/html")
+      end
+    end
+    
+    
+    describe ".from" do
+      it "receives mime_type and content" do
+        assert_equal "->application/xml: <xml/>", @c.from("application/xml", "<xml/>")
+      end
+    end
+    
+    describe "#to" do
+      it "receives mime_type" do
+        assert_equal "->application/xml", @c.new.to("application/xml")
+      end
+    end
+  end
+end

data/test/representer_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class RepresenterTest < MiniTest::Spec
+  describe "Representer" do
+    before do
+      @c = Class.new(Roar::Representer::Base)
+    end
+    
+    it "aliases #representable_property to #property" do
+      @c.property :title
+      assert_equal "title", @c.representable_attrs.first.name
+    end
+    
+    it "aliases #representable_collection to #collection" do
+      @c.collection :songs
+      assert_equal "songs", @c.representable_attrs.first.name
+    end
+    
+    it "accepts property hash in #new" do
+      @c.property :title
+      assert_equal "Counting Down", @c.new(:title => "Counting Down").title
+    end
+    
+  end
+end

data/test/ruby_representation_test.rb

@@ -0,0 +1,144 @@
+require 'test_helper'
+
+module Roar
+  module Representer
+    class Ruby < Base
+      def serialize(attributes)
+        serializable_attributes = attributes.dup
+        
+        serialize_typed_attributes(serializable_attributes)
+        Marshal.dump serializable_attributes
+      end
+      
+      def deserialize(body)
+        deserialized_hash = Marshal.load body
+        deserialize_typed_attributes(deserialized_hash)
+      end
+      
+      
+      
+      module ConfigurationDsl # FIXME: move to Representer::BaseDsl or so.
+        def has_many(name, options={})
+          collections[name] = options
+        end
+        alias_method :collection, :has_many
+        
+        def has_one(name, options={})
+          typed_entities[name] = options
+        end
+        
+        def has_proxied(name, options={})
+          has_one(name, {:class => EntityProxy.class_for(options)}) 
+        end
+        
+        def has_many_proxied(name, options={})
+          has_many(name, {:class => EntityProxy.class_for(options)}) 
+        end
+      end
+      
+      self.extend ConfigurationDsl
+      # FIXME: use one variable?
+      extend Hooks::InheritableAttribute
+      inheritable_attr :collections
+      self.collections = {}
+      inheritable_attr :typed_entities
+      self.typed_entities = {}
+      
+      
+      
+      def serialize_typed_attributes(attributes)
+          filter_attributes_for(attributes, self.class.typed_entities) do |name, options|
+            next unless entity = attributes[name]
+            attributes[name] = entity.to(mime_type)
+          end
+        end
+      
+      # Attributes can be typecasted with +has_one+.
+        def deserialize_typed_attributes(attributes)
+          filter_attributes_for(attributes, self.class.typed_entities) do |name, options|
+            item  = attributes.delete(name)                        # attributes[:sum]
+            item  = options[:class].from(mime_type, item) # Sum.from_xml_attributes
+            attributes[name] = item
+          end
+        end
+        
+        def filter_attributes_for(attributes, config)
+          config.each do |name, options|
+            name = name.to_s
+            yield name, options
+          end
+          attributes
+        end
+      
+    end
+    
+    
+  end
+  
+end
+
+
+class RubyRepresenterFunctionalTest < MiniTest::Spec
+  class Item
+    attr_reader :value
+    
+    def initialize(value)
+      @value = value
+    end
+    
+    def to(mime_type)
+      raise unless mime_type == "ruby/serialized"
+      Marshal.dump(@value)
+    end
+    
+    def self.from(mime_type, string)
+      raise unless mime_type == "ruby/serialized"
+      new Marshal.load(string)
+    end
+    
+    def ==(b)
+      value == b.value
+    end
+  end
+  
+  describe "RubyRepresenter" do
+    before do
+      @r = Class.new(Roar::Representer::Ruby).new("ruby/serialized")
+      @m = {:id => 1}
+    end
+    
+    describe "without options" do
+      it "#serialize returns the serialized model" do
+        assert_equal "\x04\b{\x06:\aidi\x06", @r.serialize(@m)
+      end
+      
+      it "#deserialize returns the attributes" do
+        assert_equal @m, @r.deserialize("\x04\b{\x06:\aidi\x06")
+      end
+    end
+    
+    
+    describe "has_one" do
+      before do
+        @r.class.instance_eval do
+          has_one :item, :class => Item
+        end
+      end
+      
+      it "#serialize skips empty :item" do
+        assert_equal "\x04\b{\x06:\aidi\x06", @r.serialize(@m)
+      end
+      
+      it "#serialize delegates to item#to" do
+        @m = {:id => 1, "item" => Item.new("beer")}
+        assert_equal "\x04\b{\a:\aidi\x06I\"\titem\x06:\x06EF\"\x13\x04\bI\"\tbeer\x06:\x06EF", @r.serialize(@m)
+      end
+      
+      it "#deserialize typecasts :item" do
+        m = @r.deserialize("\x04\b{\a:\aidi\x06I\"\titem\x06:\x06EF\"\x13\x04\bI\"\tbeer\x06:\x06EF")
+        assert_equal({:id => 1, "item" => Item.new("beer")}, m)
+      end
+      
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,45 @@
+require 'bundler'
+Bundler.setup
+
+require 'test/unit'
+require 'minitest/spec'
+
+require 'active_model'
+#require 'roar/client/entity_proxy'
+require 'roar/representer'
+require 'roar/model'
+require 'roar/representer/feature/http_verbs'
+
+require 'stringio'  # FIXME. remove for 3.0.4.
+require 'builder'
+
+
+class Item
+  include Roar::Model
+  accessors :value
+  
+  def self.model_name
+    "item"
+  end
+end
+
+class Position
+  include Roar::Model
+  accessors :id, :item
+  
+  def self.model_name
+    :order
+  end
+end
+
+class Order
+  include Roar::Model
+  accessors :id, :items
+  
+  def self.model_name
+    :order
+  end
+end
+
+require "test_xml/mini_test"
+require "roar/representer/xml"

data/test/test_helper_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+require 'roar/model'
+
+class AssertModelTest < MiniTest::Spec
+  class Song
+    include Roar::Model
+    accessors :title
+  end
+
+  class Album
+    include Roar::Model
+    accessors :songs
+  end
+  
+  class Play
+    include Roar::Model
+    accessors :song
+  end
+  
+
+  describe "#assert_model" do
+    before do
+      @jerk     = Song.new(:title => "Jerk")
+      @sellout  = Song.new(:title => "Sellout")
+      @saleout  = Song.new(:title => "Sellout")
+    end
+    
+    it "compares to plain models" do
+      assert_model @jerk,     @jerk
+      assert_model @sellout,  @saleout
+      
+      assert_raises MiniTest::Assertion do
+        assert_model @jerk, @sellout
+      end
+    end
+    
+    it "compares nested models" do
+      @play    = Play.new(:song => @sellout)
+      @play_2  = Play.new(:song => @saleout)
+      assert_model @play, @play_2
+      
+      assert_raises MiniTest::Assertion do
+        assert_model @play, Play.new(:song => @jerk)
+      end
+    end
+    
+    it "compares nested models in collections" do
+      @stay_asleep = Album.new(:songs => [@jerk, @sellout])
+      @stay_asleep_ripped = Album.new(:songs => [@jerk, @saleout])
+      assert_model @stay_asleep, @stay_asleep_ripped
+      
+      assert_raises MiniTest::Assertion do
+        assert_model assert_model @stay_asleep, Album.new(:songs => [@jerk])
+      end
+    end
+    
+    
+  end
+end

data/test/transport_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+require 'roar/client/transport'
+
+class TransportTest < MiniTest::Spec
+  describe "Transport" do
+    before do
+      @klass = Class.new(Object) do
+        include Roar::Client::Transport
+      end
+      @o = @klass.new
+    end
+    
+    it "#get_uri returns Restfulie response" do
+      assert_equal "<method>get</method>",  @o.get_uri("http://localhost:9999/method", "application/xml").body
+    end
+    
+    it "#post_uri returns Restfulie response" do
+      assert_equal "<method>post</method>",  @o.post_uri("http://localhost:9999/method", "booty", "application/xml").body
+    end
+    
+    it "#put_uri returns Restfulie response" do
+      assert_equal "<method>put</method>",  @o.put_uri("http://localhost:9999/method", "booty", "application/xml").body
+    end
+    
+    it "#delete_uri returns Restfulie response" do
+      assert_equal "<method>delete</method>",  @o.delete_uri("http://localhost:9999/method", "application/xml").body
+    end
+    
+    # TODO: how to get PATCH into Sinatra?
+    #it "#patch_uri returns Restfulie response" do
+    #  assert_equal "<method>patch</method>",  @o.patch_uri("http://localhost:9999/method", "booty", "application/xml").body
+    #end
+  end
+end

data/test/xml_hypermedia_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class XmlHypermediaTest < MiniTest::Spec
+  describe "Hypermedia API" do
+    before do
+      @c = Class.new(Roar::Representer::XML) do
+        self.representation_name= :wuff
+        representable_property :id
+        link :self do "http://self" end
+        link :next do "http://next/#{id}" end
+      end
+      @r = @c.new
+    end
+    
+    it "responds to #links" do
+      assert_equal nil, @r.links
+    end
+    
+    it "computes links in #from_attributes" do
+      @r = @c.from_attributes({"id" => 1})
+      assert_equal 2, @r.links.size
+      assert_equal({"rel"=>:self, "href"=>"http://self"}, @r.links.first.to_attributes)
+      assert_equal({"rel"=>:next, "href"=>"http://next/1"}, @r.links.last.to_attributes) 
+    end
+    
+    it "extracts links from XML" do
+      @r = @c.deserialize(%{
+      <order>
+        <link rel="self" href="http://self">
+      </order>
+      })
+      
+      assert_kind_of Roar::Representer::Feature::Hypermedia::LinkCollection, @r.links
+      assert_equal 1, @r.links.size
+      assert_equal({"rel"=>"self", "href"=>"http://self"}, @r.links.first.to_attributes) 
+    end
+    
+    it "renders <link> correctly in XML" do
+      assert_xml_equal %{<wuff>
+  <id>1</id>
+  <link rel="self" href="http://self"/>
+  <link rel="next" href="http://next/1"/>
+</wuff><expected />}, @c.from_attributes({"id" => 1}).serialize
+    end
+    
+  end
+end

data/test/xml_representer_test.rb

@@ -0,0 +1,238 @@
+require 'test_helper'
+
+class Order
+  include Roar::Model
+  accessors :id, :item
+  
+  def self.model_name
+    :order
+  end
+end
+
+
+class ItemRepresenter < Roar::Representer::XML
+  self.representation_name= :item
+  representable_property :value
+end
+
+class PositionRepresenter < Roar::Representer::XML
+  self.representation_name= :position
+  representable_property :id
+  representable_property :item, :as => ItemRepresenter
+end
+
+
+
+
+class XMLRepresenterUnitTest < MiniTest::Spec
+  describe "XmlRepresenter" do
+    describe "#link" do
+      class Rapper < Roar::Representer::XML
+        link :self
+        link :next
+      end
+      
+      it "creates a LinksDefinition" do
+        assert_equal 1, Rapper.representable_attrs.size
+        assert_equal [{:rel=>:self, :block=>nil}, {:rel=>:next, :block=>nil}], Rapper.representable_attrs.first.rel2block
+      end
+    end
+    
+    describe "#from_attributes" do
+      it "accepts a block" do
+        @c = Class.new(Roar::Representer::XML) do
+          attr_accessor :name
+        end
+        
+        assert_equal("Conan", @c.from_attributes({}) { |rep| rep.name = "Conan" }.name)
+      end
+    end
+  end
+end
+
+class LinksDefinitionTest < MiniTest::Spec
+  describe "LinksDefinition" do
+    before do
+      @d = Roar::Representer::LinksDefinition.new(:links)
+    end
+    
+    it "accepts options in constructor" do
+      assert_equal [], @d.rel2block
+    end
+    
+    it "accepts configuration" do
+      @d.rel2block << {:rel => :self}
+      assert_equal [{:rel=>:self}], @d.rel2block
+    end
+  end
+end
+
+class XMLDefinitionTest < MiniTest::Spec
+  class Rapper
+    attr_accessor :name
+  end
+  
+  describe "ROXML::Definition" do
+    it "responds to #populate" do
+      @r = Rapper.new
+      Representable::Definition.new(:name).populate(@r, "name" => "Eugen")
+      assert_equal "Eugen", @r.name
+    end
+  end
+end
+
+
+
+
+
+class XMLRepresenterFunctionalTest < MiniTest::Spec
+  class GreedyOrder
+    include Roar::Model
+    accessors :id, :items
+    
+    def self.model_name
+      :order
+    end
+  end
+  
+  class TestXmlRepresenter < Roar::Representer::XML
+    self.representation_name= :order  # FIXME: get from represented?
+    representable_property :id
+  end
+  
+  
+  describe "XMLRepresenter" do
+    before do
+      @m = {"id" => "1"}
+      @o = Order.new(@m)
+      @r = TestXmlRepresenter.new
+      @i = ItemRepresenter.new
+      @i.value = "Beer"
+    end
+    
+    describe "#from_attributes" do
+      it "copies represented attributes, only" do
+        @r = PositionRepresenter.from_attributes("id" => 1, "item" => @i, "unknown" => 1)
+        assert_kind_of PositionRepresenter, @r
+        assert_equal 1, @r.id
+        
+        assert_kind_of ItemRepresenter, @r.item
+        assert_equal @r.item.value, "Beer"
+      end
+    end
+    
+    
+    describe "#to_attributes" do
+      it "returns a nested attributes hash" do
+        @r = PositionRepresenter.from_attributes("id" => 1, "item" => @i)
+        assert_equal({"id" => 1, "item" => {"value" => "Beer"}}, @r.to_attributes)
+      end
+    end
+    
+    
+    describe "#to_xml" do
+      it "serializes the current model" do
+        assert_xml_equal "<order/>", @r.to_xml.serialize
+        
+        @r.id = 2
+        assert_xml_equal "<rap><id>2</id></rap>", @r.to_xml(:name => :rap).serialize
+      end
+    end
+    
+    
+    describe "without options" do
+      it "#serialize returns the serialized model" do
+        @r.id = 1
+        assert_xml_equal "<order><id>1</id></order>", @r.serialize
+      end
+      
+      
+      it ".from_xml returns the deserialized model" do
+        @m = TestXmlRepresenter.deserialize("<order><id>1</id></order>")
+        assert_equal "1", @m.id
+      end
+      
+      it ".from_xml still works with nil" do
+        assert TestXmlRepresenter.deserialize(nil)
+      end
+      
+    end
+    
+    
+    describe "with a typed attribute" do
+      before do
+        @r = PositionRepresenter.from_attributes("id" => "1")
+      end
+      
+      it "#serialize skips empty :item" do
+        assert_xml_equal "<position><id>1</id></position>", @r.serialize
+      end
+      
+      it "#to_xml delegates to ItemRepresenter#to_xml" do
+        @r.item = @i
+        assert_xml_equal "<position><id>1</id><item><value>Beer</value></item></position>", @r.serialize
+      end
+      
+      it ".from_xml typecasts :item" do
+        @m = PositionRepresenter.deserialize("<position><id>1</id><item><value>beer</value></item>\n</position>")
+        
+        assert_equal "1",     @m.id
+        assert_equal "beer",  @m.item.value
+      end
+    end
+    
+    
+    describe "with a typed list" do
+      before do
+        @c = Class.new(Roar::Representer::XML) do
+          self.representation_name= :order
+          representable_property :id
+          representable_collection :items, :as => ItemRepresenter, :tag => :item
+        end
+        
+        @r = @c.from_attributes("id" => 1)
+      end
+      
+      it "#serialize_model skips empty :item" do
+        assert_xml_equal "<order><id>1</id></order>", @r.serialize
+      end
+      
+      it "#serialize delegates to ItemXmlRepresenter#to_xml in list" do
+        @r.items = [ItemRepresenter.from_attributes("value" => "Bier")]
+        
+        assert_xml_equal "<order><id>1</id><item><value>Bier</value></item></order>", 
+          @r.serialize
+      end
+      
+      it ".from_xml typecasts list" do
+        @m = @c.deserialize("<order><id>1</id><item><value>beer</value></item>\n</order>")
+        
+        assert_equal "1",     @m.id
+        assert_equal 1,       @m.items.size
+        assert_equal "beer",  @m.items.first.value
+      end
+    end
+    
+  end
+end
+
+class XmlHyperlinkRepresenterTest < MiniTest::Spec
+  describe "API" do
+    before do
+      @l = Roar::Representer::XML::Hyperlink.from_xml(%{<link rel="self" href="http://roar.apotomo.de"/>})
+    end
+    
+    it "responds to #representation_name" do
+      assert_equal :link, @l.class.representation_name
+    end
+    
+    
+    it "responds to #rel" do
+      assert_equal "self", @l.rel
+    end
+    
+    it "responds to #href" do
+      assert_equal "http://roar.apotomo.de", @l.href
+    end
+  end
+end