roar 1.0.2 → 1.1.1

data/test/json_api_test.rb

@@ -1,451 +0,0 @@
-require 'test_helper'
-require 'roar/json/json_api'
-require 'json'
-
-require "representable/version"
-if Gem::Version.new(Representable::VERSION) >= Gem::Version.new("2.1.4") # TODO: remove check once we bump representable dependency.
-  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, if: lambda { |args| args[:omit_title] != true }
-
-      # 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, if: lambda { |args| args[:omit_title] != true }
-
-      # NOTE: it is important to call has_one, then links, then has_many to assert that they all write
-      #to the same _links property and do NOT override things.
-      has_one :composer
-      # local per-model "id" links
-      links do
-        property :album_id, :as => :album
-        collection :musician_ids, :as => :musicians
-      end
-      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_hash(options)
-        it do
-          subject.to_hash(omit_title: true)['songs'].wont_include('title')
-        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 with #{representer}" do
-        subject { representer.for_collection.prepare([song, song]) }
-
-        let (:document) do
-          {
-            "songs" => [
-              {
-                "id" => "1",
-                "title" => "Computadores Fazem Arte",
-                "links" => {
-                  "composer"=>"10",
-                  "album" => "9",
-                  "musicians" => [ "1", "2" ],
-                  "listeners"=>["8"]
-                }
-              }, {
-                "id" => "1",
-                "title" => "Computadores Fazem Arte",
-                "links" => {
-                  "composer"=>"10",
-                  "album" => "9",
-                  "musicians" => [ "1", "2" ],
-                  "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_hash(options)
-        it do
-          subject.to_hash(omit_title: true)['songs'].each do |song|
-            song.wont_include('title')
-          end
-        end
-
-        # #to_json
-        it { subject.to_json.must_match /linked/ } # hash ordering changes, and i don't care why.
-      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
-
-    class CompoundCollectionUsingExtend < self
-      module SongRepresenter
-        include Roar::JSON::JSONAPI
-
-        type :songs
-        property :id
-        property :title
-      end
-
-      module AlbumRepresenter
-        include Roar::JSON::JSONAPI
-
-        type :albums
-        property :id
-        compound do
-          collection :songs, extend: SongRepresenter
-        end
-      end
-
-      let(:songs) do
-        struct = Struct.new(:id, :title)
-        [struct.new(1, 'Stand Up'), struct.new(2, 'Audition Mantra')]
-      end
-
-      let(:album) { Struct.new(:id, :songs).new(1, songs) }
-
-      subject { album.extend(AlbumRepresenter) }
-
-      # to_hash
-      it do
-        subject.to_hash.must_equal({
-          'albums' => { 'id' => 1 },
-          'linked' => {
-            'songs' => [
-              {'id' => 1, 'title' => 'Stand Up'},
-              {'id' => 2, 'title' => 'Audition Mantra'}
-            ]
-          }
-        })
-      end
-    end
-
-    class ExplicitMeta < self
-      module Representer
-        include Roar::JSON::JSONAPI
-
-        type :songs
-        property :id
-
-        meta do
-          property :page
-        end
-      end
-
-      module Page
-        def page
-          2
-        end
-      end
-
-      let (:song) { Struct.new(:id).new(1) }
-
-      subject { [song, song].extend(Representer.for_collection).extend(Page) }
-
-      # to_json
-      it do
-        subject.to_hash.must_equal(
-          {
-            "songs"=>[{"id"=>1}, {"id"=>1}],
-            "meta" =>{"page"=>2}
-          }
-        )
-      end
-    end
-
-
-    class ImplicitMeta < self
-      module Representer
-        include Roar::JSON::JSONAPI
-
-        type :songs
-        property :id
-      end
-
-      let (:song) { Struct.new(:id).new(1) }
-
-      subject { [song, song].extend(Representer.for_collection) }
-
-      # to_json
-      it do
-        subject.to_hash("meta" => {"page" => 2}).must_equal(
-          {
-            "songs"=>[{"id"=>1}, {"id"=>1}],
-            "meta" =>{"page"=>2}
-          }
-        )
-      end
-    end
-  end
-end

data/test/lib/runner.rb

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