roar 0.12.9 → 1.0.0.beta1

data/test/integration/ssl_server.rb

@@ -57,4 +57,4 @@ class SslServer < Sinatra::Base
 end
 server = ::Rack::Handler::WEBrick
 
-server.run(SslServer, webrick_options)
+server.run(SslServer, webrick_options)

data/test/json_api_test.rb

@@ -0,0 +1,336 @@
+require 'test_helper'
+require 'roar/json/json_api'
+
+class JSONAPITest < MiniTest::Spec
+  let(:song) {
+    s = OpenStruct.new(
+      bla: "halo",
+      id: "1",
+      title: 'Computadores Fazem Arte',
+      album: OpenStruct.new(id: 9, title: "Hackers"),
+      :album_id => "9",
+      :musician_ids => ["1","2"],
+      :composer_id => "10",
+      :listener_ids => ["8"],
+      musicians: [OpenStruct.new(id: 1, name: "Eddie Van Halen"), OpenStruct.new(id: 2, name: "Greg Howe")]
+    )
+
+  }
+
+  # minimal resource, singular
+  module MinimalSingular
+    include Roar::JSON::JSONAPI
+    type :songs
+
+    property :id
+  end
+
+  class MinimalSingularDecorator < Roar::Decorator
+    include Roar::JSON::JSONAPI
+    type :songs
+
+    property :id
+  end
+
+  [MinimalSingular, MinimalSingularDecorator].each do |representer|
+    describe "minimal singular with #{representer}" do
+      subject { representer.prepare(song) }
+
+      it { subject.to_json.must_equal "{\"songs\":{\"id\":\"1\"}}" }
+      it { subject.from_json("{\"songs\":{\"id\":\"2\"}}").id.must_equal "2"  }
+    end
+  end
+
+
+
+  module Singular
+    include Roar::JSON::JSONAPI
+    type :songs
+
+    property :id
+    property :title
+
+    # local per-model "id" links
+    links do
+      property :album_id, :as => :album
+      collection :musician_ids, :as => :musicians
+    end
+    has_one :composer
+    has_many :listeners
+
+
+    # global document links.
+    link "songs.album" do
+      {
+        type: "album",
+        href: "http://example.com/albums/{songs.album}"
+      }
+    end
+
+    compound do
+      property :album do
+        property :title
+      end
+
+      collection :musicians do
+        property :name
+      end
+    end
+  end
+
+  class SingularDecorator < Roar::Decorator
+    include Roar::JSON::JSONAPI
+    type :songs
+
+    property :id
+    property :title
+
+    # local per-model "id" links
+    links do
+      property :album_id, :as => :album
+      collection :musician_ids, :as => :musicians
+    end
+    has_one :composer
+    has_many :listeners
+
+
+    # global document links.
+    link "songs.album" do
+      {
+        type: "album",
+        href: "http://example.com/albums/{songs.album}"
+      }
+    end
+
+    compound do
+      property :album do
+        property :title
+      end
+
+      collection :musicians do
+        property :name
+      end
+    end
+  end
+
+  [Singular, SingularDecorator].each do |representer|
+    describe "singular with #{representer}" do
+      subject { song.extend(Singular) }
+
+      let (:document) do
+        {
+          "songs" => {
+            "id" => "1",
+            "title" => "Computadores Fazem Arte",
+            "links" => {
+              "album" => "9",
+              "musicians" => [ "1", "2" ],
+              "composer"=>"10",
+              "listeners"=>["8"]
+            }
+          },
+          "links" => {
+            "songs.album"=> {
+              "href"=>"http://example.com/albums/{songs.album}", "type"=>"album"
+            }
+          },
+          "linked" => {
+            "album"=> [{"title"=>"Hackers"}],
+            "musicians"=> [
+              {"name"=>"Eddie Van Halen"},
+              {"name"=>"Greg Howe"}
+            ]
+          }
+        }
+      end
+
+      # to_hash
+      it do
+        subject.to_hash.must_equal document
+      end
+
+      # #to_json
+      it do
+        subject.to_json.must_equal JSON.generate(document)
+      end
+
+      # #from_json
+      it do
+        song = OpenStruct.new.extend(Singular)
+        song.from_json(
+          JSON.generate(
+            {
+              "songs" => {
+                "id" => "1",
+                "title" => "Computadores Fazem Arte",
+                "links" => {
+                  "album" => "9",
+                  "musicians" => [ "1", "2" ],
+                  "composer"=>"10",
+                  "listeners"=>["8"]
+                }
+              },
+              "links" => {
+                "songs.album"=> {
+                  "href"=>"http://example.com/albums/{songs.album}", "type"=>"album"
+                }
+              }
+            }
+          )
+        )
+
+        song.id.must_equal "1"
+        song.title.must_equal "Computadores Fazem Arte"
+        song.album_id.must_equal "9"
+        song.musician_ids.must_equal ["1", "2"]
+        song.composer_id.must_equal "10"
+        song.listener_ids.must_equal ["8"]
+      end
+    end
+  end
+
+
+  # collection with links
+  [Singular, SingularDecorator].each do |representer|
+    describe "collection with links and compound" do
+      subject { Singular.for_collection.prepare([song, song]) }
+
+      let (:document) do
+        {
+          "songs" => [
+            {
+              "id" => "1",
+              "title" => "Computadores Fazem Arte",
+              "links" => {
+                "album" => "9",
+                "musicians" => [ "1", "2" ],
+                "composer"=>"10",
+              "listeners"=>["8"]
+              }
+            }, {
+              "id" => "1",
+              "title" => "Computadores Fazem Arte",
+              "links" => {
+                "album" => "9",
+                "musicians" => [ "1", "2" ],
+                "composer"=>"10",
+              "listeners"=>["8"]
+              }
+            }
+          ],
+          "links" => {
+            "songs.album" => {
+              "href" => "http://example.com/albums/{songs.album}",
+              "type" => "album" # DISCUSS: does that have to be albums ?
+            },
+          },
+          "linked"=>{
+            "album"    =>[{"title"=>"Hackers"}], # only once!
+            "musicians"=>[{"name"=>"Eddie Van Halen"}, {"name"=>"Greg Howe"}]
+          }
+        }
+      end
+
+      # to_hash
+      it do
+        subject.to_hash.must_equal document
+      end
+
+      # #to_json
+      it { subject.to_json.must_equal JSON.generate(document) }
+    end
+
+
+    # from_json
+    it do
+      song1, song2 = Singular.for_collection.prepare([OpenStruct.new, OpenStruct.new]).from_json(
+        JSON.generate(
+          {
+            "songs" => [
+              {
+                "id" => "1",
+                "title" => "Computadores Fazem Arte",
+                "links" => {
+                  "album" => "9",
+                  "musicians" => [ "1", "2" ],
+                  "composer"=>"10",
+                  "listeners"=>["8"]
+                },
+              },
+              {
+                "id" => "2",
+                "title" => "Talking To Remind Me",
+                "links" => {
+                  "album" => "1",
+                  "musicians" => [ "3", "4" ],
+                  "composer"=>"2",
+                  "listeners"=>["6"]
+                }
+              },
+            ],
+            "links" => {
+              "songs.album"=> {
+                "href"=>"http://example.com/albums/{songs.album}", "type"=>"album"
+              }
+            }
+          }
+        )
+      )
+
+      song1.id.must_equal "1"
+      song1.title.must_equal "Computadores Fazem Arte"
+      song1.album_id.must_equal "9"
+      song1.musician_ids.must_equal ["1", "2"]
+      song1.composer_id.must_equal "10"
+      song1.listener_ids.must_equal ["8"]
+
+      song2.id.must_equal "2"
+      song2.title.must_equal "Talking To Remind Me"
+      song2.album_id.must_equal "1"
+      song2.musician_ids.must_equal ["3", "4"]
+      song2.composer_id.must_equal "2"
+      song2.listener_ids.must_equal ["6"]
+    end
+  end
+
+
+  class CollectionWithoutCompound <  self
+    module Representer
+      include Roar::JSON::JSONAPI
+      type :songs
+
+      property :id
+      property :title
+
+      # local per-model "id" links
+      links do
+        property :album_id, :as => :album
+        collection :musician_ids, :as => :musicians
+      end
+      has_one :composer
+      has_many :listeners
+
+
+      # global document links.
+      link "songs.album" do
+        {
+          type: "album",
+          href: "http://example.com/albums/{songs.album}"
+        }
+      end
+    end
+
+    subject { [song, song].extend(Singular.for_collection) }
+
+    # to_json
+    it do
+      subject.extend(Representer.for_collection).to_hash.must_equal(
+        {
+          "songs"=>[{"id"=>"1", "title"=>"Computadores Fazem Arte", "links"=>{"album"=>"9", "musicians"=>["1", "2"], "composer"=>"10", "listeners"=>["8"]}}, {"id"=>"1", "title"=>"Computadores Fazem Arte", "links"=>{"album"=>"9", "musicians"=>["1", "2"], "composer"=>"10", "listeners"=>["8"]}}],
+          "links"=>{"songs.album"=>{"href"=>"http://example.com/albums/{songs.album}", "type"=>"album"}
+          }
+        }
+      )
+    end
+  end
+end

data/test/json_representer_test.rb

@@ -1,14 +1,18 @@
 require 'test_helper'
 
 require "test_xml/mini_test"
-require "roar/representer/json"
+require "roar/json"
 
 class JsonRepresenterTest < MiniTest::Spec
   class Order
-    include Roar::Representer::JSON
+    include Roar::JSON
     property :id
     property :pending
     attr_accessor :id, :pending
+
+    def id=(v) # in ruby 2.2, #id= is not there, all at sudden. what *is* that?
+      @id=v
+    end
   end
 
 
@@ -63,7 +67,7 @@ class JsonRepresenterTest < MiniTest::Spec
 
     describe "JSON.from_json" do
       it "is aliased by #deserialize" do
-        @order = Order.deserialize('{"id":1}')
+        @order = Order.new.deserialize('{"id":1}')
         assert_equal 1, @order.id
       end
     end
@@ -74,7 +78,7 @@ end
 class JsonHyperlinkRepresenterTest
   describe "API" do
     before do
-      @link = Roar::Representer::Feature::Hypermedia::Hyperlink.new.extend(Roar::Representer::JSON::HyperlinkRepresenter).from_json(
+      @link = Roar::Hypermedia::Hyperlink.new.extend(Roar::JSON::HyperlinkRepresenter).from_json(
         '{"rel":"self", "href":"http://roar.apotomo.de", "media":"web"}')
     end
 
@@ -101,8 +105,8 @@ class JsonHypermediaTest
     before do
       @c = Class.new do
         include AttributesConstructor
-        include Roar::Representer::JSON
-        include Roar::Representer::Feature::Hypermedia
+        include Roar::JSON
+        include Roar::Hypermedia
         attr_accessor :id, :self, :next
 
         property :id
@@ -115,14 +119,14 @@ class JsonHypermediaTest
     end
 
     it "responds to #links" do
-      @r.links.must_equal({})
+      @r.links.must_equal nil
     end
 
     it "extracts links from JSON" do
-      r = @c.from_json('{"links":[{"rel":"self","href":"http://self"}]}')
+      r = @r.from_json('{"links":[{"rel":"self","href":"http://self"}]}')
 
-      assert_equal 1, r.links_array.size
-      link = r.links_array.first
+      assert_equal 1, r.links.size
+      link = r.links["self"]
       assert_equal(["self", "http://self"], [link.rel, link.href])
     end
 
@@ -132,8 +136,8 @@ class JsonHypermediaTest
 
     it "doesn't render links when empty" do
       assert_equal("{\"links\":[]}", Class.new do
-        include Roar::Representer::JSON
-        include Roar::Representer::Feature::Hypermedia
+        include Roar::JSON
+        include Roar::Hypermedia
 
         link :self do nil end
         link :next do false end

data/test/lib/runner.rb

@@ -0,0 +1,134 @@
+require 'open-uri'
+require 'net/http'
+require 'timeout'
+
+# Helps you spinning up and shutting down your own sinatra app. This is especially helpful for running
+# real network tests against a sinatra backend.
+#
+# The backend server could look like the following (in test/server.rb).
+#
+#   require "sinatra"
+#
+#   get "/" do
+#     "Cheers from test server"
+#   end
+#
+#   get "/ping" do
+#     "1"
+#   end
+#
+# Note that you need to implement a ping action for internal use.
+#
+# Next, you need to write your runner.
+#
+#   require 'sinatra/runner'
+#
+#   class Runner < Sinatra::Runner
+#     def app_file
+#       File.expand_path("../server.rb", __FILE__)
+#     end
+#   end
+#
+# Override Runner#app_file, #command, #port, #protocol and #ping_path for customization.
+#
+# Whereever you need this test backend, here's how you manage it. The following example assumes you
+# have a test in your app that needs to be run against your test backend.
+#
+#   runner = ServerRunner.new
+#   runner.run
+#
+#   # ..tests against localhost:4567 here..
+#
+#   runner.kill
+#
+# For an example, check https://github.com/apotonick/roar/blob/master/test/test_helper.rb
+module Sinatra
+  class Runner
+    def app_file
+      File.expand_path("../server.rb", __FILE__)
+    end
+
+    def run
+      #puts command
+      @pipe     = start
+      @started  = Time.now
+      warn "#{server} up and running on port #{port}" if ping
+    end
+
+    def kill
+      return unless pipe
+      Process.kill("KILL", pipe.pid)
+    rescue NotImplementedError
+      system "kill -9 #{pipe.pid}"
+    rescue Errno::ESRCH
+    end
+
+    def get(url)
+      Timeout.timeout(1) { get_url("#{protocol}://127.0.0.1:#{port}#{url}") }
+    end
+
+    def log
+      @log ||= ""
+      loop { @log <<  pipe.read_nonblock(1) }
+    rescue Exception
+      @log
+    end
+
+  private
+    attr_accessor :pipe
+
+    def start
+      IO.popen(command)
+    end
+
+    def command # to be overwritten
+      "bundle exec ruby #{app_file} -p #{port} -e production"
+    end
+
+    def ping(timeout=30)
+      loop do
+        return if alive?
+        if Time.now - @started > timeout
+          $stderr.puts command, log
+          fail "timeout"
+        else
+          sleep 0.1
+        end
+      end
+    end
+
+    def alive?
+      3.times { get(ping_path) }
+      true
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, EOFError, SystemCallError, OpenURI::HTTPError, Timeout::Error
+      false
+    end
+
+    def ping_path # to be overwritten
+      '/ping'
+    end
+
+    def port # to be overwritten
+      4567
+    end
+
+    def protocol
+      "http"
+    end
+
+    def get_url(url)
+      uri = URI.parse(url)
+
+      return uri.read unless protocol == "https"
+      get_https_url(uri)
+    end
+
+    def get_https_url(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl      = true
+      http.verify_mode  = OpenSSL::SSL::VERIFY_NONE
+      request = Net::HTTP::Get.new(uri.request_uri)
+      http.request(request).body
+    end
+  end
+end