jsonapi_spec_helpers 0.4.10 → 1.0.alpha.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7de8f729627057f5996f8455bc769caf8d0f5bbd
-  data.tar.gz: 05436bab3f0d5377a8ecdffc549f10e475233d5e
+  metadata.gz: 17ecff418f690fa93ed1e4a44d139c46a9b00beb
+  data.tar.gz: 4e74adb0ea0593f7a28e7bc7485f20e6d55a1d08
 SHA512:
-  metadata.gz: 9ec2ad279e5282fb83f7899d29af184e56efc37ee4aaa81eaa8020fbcbce920e0c3b49d66868219190c4c3a14a84f15fd9b78f10a22adf529b028550e4fc84f9
-  data.tar.gz: da684de42e3c316343abcba437afcbc447a2fa6a44771778a75516feec6aba1be69d76cb25f50b248d853da0de319a9b235f13558b8efa5d7278fe2269f6d4b8
+  metadata.gz: 58f02d6265d70de7e97c544646698e71852421ae213f53e74f5e4bb187ffafb6fb29fabb63929906fbfea8a8d7f5a4cd6996a1514ee620a6e38e23e99903582c
+  data.tar.gz: c216961f4a62b64fb0a42058c1a3fcab986a9c1e4b43a2a7f1da61f8981b90bceb4eeb4b9f57263d902f62f78caae97f3ef529706893f6ed27d851a420237ecd

data/jsonapi_spec_helpers.gemspec

@@ -23,5 +23,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "actionpack", "~> 5.0"
   spec.add_development_dependency "bundler", "~> 1.11"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "jsonapi_compliable", '>= 1.0.alpha.1'
   spec.add_dependency "rspec", "~> 3.0"
 end

data/lib/jsonapi_spec_helpers/errors.rb

@@ -1,16 +1,51 @@
 module JsonapiSpecHelpers
   module Errors
     class Base < StandardError; end
-    class IncludedOutOfBounds < Base
-      def initialize(type, index, array)
-        @type = type; @index = index; @array = array
+
+    class LinksNotFound < Base
+      def initialize(name)
+        @name = name
+      end
+
+      def message
+        "Relationship with name '#{@name}' has no links!"
+      end
+    end
+
+    class SideloadNotFound < Base
+      def initialize(name)
+        @name = name
+      end
+
+      def message
+        "Relationship with name '#{@name}' not found!"
+      end
+    end
+
+    class NoResponse < Base
+      def message
+        "Cannot parse response - missing #response.body!"
+      end
+    end
+
+    class NoData < Base
+      def initialize(payload)
+        @payload = payload
+      end
+
+      def message
+        "Payload did not contain 'data'! Payload was:\n\n#{JSON.pretty_generate(@payload)}"
+      end
+    end
+
+    class NoSideloads < Base
+      def initialize(payload)
+        @payload = payload
       end
 
       def message
-        "You attempted to get an item at index #{@index} of the type '#{@type}' " \
-        "from the included property of your JSON payload. But it contained "    \
-        "#{@array.length} '#{@type}'"
+        "Tried to find sideload, but the payload did not contain 'included'! Payload was:\n\n#{JSON.pretty_generate(@payload)}"
       end
     end
   end
-end
+end

data/lib/jsonapi_spec_helpers/errors_proxy.rb

@@ -0,0 +1,70 @@
+module JsonapiSpecHelpers
+  class ErrorsProxy
+    class Error
+      attr_reader :json
+
+      def initialize(json)
+        @json = json
+      end
+
+      def attribute
+        @json[:meta][:attribute]
+      end
+
+      # TODO: move to top-level code in errorable
+      def code
+        @json[:meta][:code]
+      end
+
+      def message
+        @json[:meta][:message]
+      end
+
+      def title
+        @json[:title]
+      end
+
+      def detail
+        @json[:detail]
+      end
+
+      def status
+        @json[:status]
+      end
+    end
+
+    include Enumerable
+
+    def initialize(array)
+      @errors = array.map { |e| Error.new(e) }
+    end
+
+    def [](key)
+      @errors[key]
+    end
+
+    def each(&blk)
+      @errors.each(&blk)
+    end
+
+    def length
+      count
+    end
+
+    def to_h
+      {}.tap do |hash|
+        @errors.each do |e|
+          hash[e.attribute] = e.message
+        end
+      end
+    end
+
+    def method_missing(id, *args, &blk)
+      if error = @errors.find { |e| e.attribute == id }
+        return error
+      else
+        super
+      end
+    end
+  end
+end

data/lib/jsonapi_spec_helpers/helpers.rb

@@ -1,77 +1,40 @@
 module JsonapiSpecHelpers
   module Helpers
-    def json
-      JSON.parse(response.body)
-    end
-
-    def json_item(from: nil)
-      from = json if from.nil?
-      data = from.has_key?('data') ? from['data'] : from
-
-      {}.tap do |item|
-        item['id'] = data['id']
-        item['jsonapi_type'] = data['type']
-        item.merge!(data['attributes']) if data.has_key?('attributes')
-      end
-    end
+    extend ActiveSupport::Concern
 
-    def json_items(*indices)
-      items   = []
-      json['data'].each_with_index do |datum, index|
-        included = indices.empty? || indices.include?(index)
-        items << json_item(from: datum) if included
+    def json
+      if response && response.body
+        JSON.parse(response.body).with_indifferent_access
+      else
+        raise Errors::NoResponse.new
       end
-      indices.length == 1 ? items[0] : items
-    end
-
-    def json_related_link(payload, assn_name)
-      link = payload['relationships'][assn_name]['links']['related']['href']
-      fail "link for #{assn_name} not found" unless link
-      URI.decode(link)
     end
 
-    def json_included_types
-      (json['included'] || []).map { |i| i['type'] }.uniq
-    end
-
-    def json_includes(type, *indices)
-      included = (json['included'] || []).select { |data| data['type'] == type }
-      indices  = (0...included.length).to_a if indices.empty?
-      includes = []
-      indices.each do |index|
-        single_included = included.at(index)
-        if single_included.nil?
-          raise Errors::IncludedOutOfBounds.new(type, index, included)
+    def jsonapi_data
+      @jsonapi_data ||= begin
+        if _jsonapi_data.is_a?(Hash)
+          node(from: _jsonapi_data)
+        else
+          _jsonapi_data.map { |datum| node(from: datum) }
         end
-        includes << json_item(from: single_included)
       end
-      includes
     end
 
-    def json_include(type, index = 0)
-      json_includes(type, index)[0]
-    end
+    def jsonapi_included(type = nil)
+      variable = :"@jsonapi_included#{type}"
+      memo = instance_variable_get(variable)
+      return memo if memo
 
-    def json_ids(integers = false)
-      ids = json['data'].map { |d| d['id'] }
-      ids.map! { |id| Integer(id) } if integers
-      ids
+      nodes =  _jsonapi_included.map { |i| node(from: i) }
+      if type
+        nodes.select! { |n| n.jsonapi_type == type }
+      end
+      instance_variable_set(variable, nodes)
+      nodes
     end
 
-    def validation_errors
-      @validation_errors ||= {}.tap do |errors|
-        return errors if json['errors'].nil?
-        json['errors'].each do |e|
-          attr = e['meta']['attribute'].to_sym
-          message = e['meta']['message']
-
-          if errors[attr]
-            errors[attr] = Array(errors[attr]).push(message)
-          else
-            errors[attr] = message
-          end
-        end
-      end
+    def jsonapi_errors
+      @jsonapi_errors ||= ErrorsProxy.new(json['errors'] || [])
     end
 
     def jsonapi_headers
@@ -100,8 +63,35 @@ module JsonapiSpecHelpers
       delete url, headers: jsonapi_headers
     end
 
-    def jsonapi_payload(input)
-      PayloadSanitizer.new(input).sanitize
+    def datetime(value)
+      JsonapiCompliable::Types[:datetime][:read][value]
+    end
+
+    # @api private
+    def node(from: nil)
+      from = json if from.nil?
+      data = from.has_key?('data') ? from['data'] : from
+      hash = {}
+      hash['id'] = data['id']
+      hash['jsonapi_type'] = data['type']
+      hash.merge!(data['attributes']) if data.has_key?('attributes')
+      Node.new(hash, data['relationships'], self)
+    end
+
+    private
+
+    # @api private
+    def _jsonapi_data
+      json['data'] || raise(Errors::NoData.new(json))
+    end
+
+    # @api private
+    def _jsonapi_included
+      if json.has_key?('included')
+        json['included']
+      else
+        raise Errors::NoSideloads.new(json)
+      end
     end
   end
 end

data/lib/jsonapi_spec_helpers/node.rb

@@ -0,0 +1,81 @@
+module JsonapiSpecHelpers
+  class Node
+    attr_reader :attributes, :relationships
+
+    def initialize(attributes, relationships, context)
+      @attributes = attributes.with_indifferent_access
+      @relationships = relationships
+      @context = context
+    end
+
+    def id
+      rawid.to_i
+    end
+
+    def rawid
+      @attributes['id']
+    end
+
+    def jsonapi_type
+      @attributes['jsonapi_type']
+    end
+
+    def has_key?(key)
+      @attributes.has_key?(key)
+    end
+
+    def [](key)
+      @attributes[key] || @attributes[key.to_s]
+    end
+
+    def []=(key, val)
+      @attributes[key] = val
+    end
+
+    def attributes
+      @attributes
+    end
+
+    def method_missing(id, *args, &blk)
+      if @attributes.has_key?(id)
+        @attributes[id]
+      else
+        super
+      end
+    end
+
+    def link(relationship_name, name)
+      if @relationships.has_key?(relationship_name)
+        links = @relationships[relationship_name][:links]
+        raise Errors::LinksNotFound.new(relationship_name) unless links
+        links[name]
+      else
+        raise Errors::SideloadNotFound.new(relationship_name)
+      end
+    end
+
+    def sideload(relationship_name)
+      unless @relationships.has_key?(relationship_name)
+        raise Errors::SideloadNotFound.new(relationship_name)
+      end
+      rel = @relationships[relationship_name]
+      rel = rel[:data]
+      return if rel.nil?
+      if rel.is_a?(Hash)
+        include_for(rel[:type], rel[:id])
+      else
+        rel.map { |r| include_for(r[:type], r[:id]) }
+      end
+    end
+    alias :sideloads :sideload
+
+    private
+
+    def include_for(type, id)
+      data = @context.json[:included].find do |i|
+        i[:type] == type && i[:id] == id
+      end
+      @context.node(from: data)
+    end
+  end
+end

data/lib/jsonapi_spec_helpers/rspec.rb

@@ -0,0 +1,44 @@
+require 'jsonapi_spec_helpers'
+
+::RSpec.shared_context 'resource testing', type: :resource do |parameter|
+  let(:resource)     { described_class }
+  let(:params)       { {} }
+
+  # If you need to set context:
+  #
+  # JsonapiCompliable.with_context my_context, {} do
+  #   render
+  # end
+  def render(runtime_options = {})
+    json = proxy.to_jsonapi(runtime_options)
+    response.body = json
+    json
+  end
+
+  def proxy
+    @proxy ||= begin
+      ctx = ::JsonapiSpecHelpers::TestRunner.new(resource, params)
+      defined?(base_scope) ? ctx.proxy(base_scope) : ctx.proxy
+    end
+  end
+
+  def records
+    proxy.data
+  end
+
+  def response
+    @response ||= OpenStruct.new
+  end
+end
+
+module JsonapiSpecHelpers
+  module RSpec
+    def self.included(klass)
+      klass.send(:include, JsonapiSpecHelpers)
+
+      ::RSpec.configure do |rspec|
+        rspec.include_context "resource testing", type: :resource
+      end
+    end
+  end
+end

data/lib/jsonapi_spec_helpers/version.rb

@@ -1,3 +1,3 @@
 module JsonapiSpecHelpers
-  VERSION = "0.4.10"
+  VERSION = "1.0.alpha.2"
 end

data/lib/jsonapi_spec_helpers.rb

@@ -1,58 +1,37 @@
 require 'json'
+require 'pp'
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/hash'
+require 'jsonapi_compliable'
+
 require 'jsonapi_spec_helpers/version'
 require 'jsonapi_spec_helpers/helpers'
-require 'jsonapi_spec_helpers/payload'
-require 'jsonapi_spec_helpers/payload_sanitizer'
+require 'jsonapi_spec_helpers/node'
+require 'jsonapi_spec_helpers/errors_proxy'
 require 'jsonapi_spec_helpers/errors'
 
 module JsonapiSpecHelpers
   def self.included(klass)
-    # don't load RSpec until included
-    require 'jsonapi_spec_helpers/matchers'
     klass.send(:include, Helpers)
-    if defined?(Rails)
-      load_payloads!
-    end
   end
 
-  def self.load_payloads!
-    Dir[Rails.root.join('spec/payloads/**/*.rb')].each { |f| require f }
+  class TestRunner < ::JsonapiCompliable::Runner
+    def current_user
+      nil
+    end
   end
 
-  def assert_payload(name, record, json, &blk)
-    unless payload = JsonapiSpecHelpers::Payload.registry[name]
-      raise "No payloads registered for '#{name}'"
+  module Sugar
+    def d
+      jsonapi_data
     end
 
-    if blk
-      payload = payload.fork
-      payload.instance_eval(&blk)
+    def included(type = nil)
+      jsonapi_included(type)
     end
 
-    aggregate_failures "payload has correct key/values" do
-      payload.keys.each_pair do |attribute, options|
-        prc = options[:proc]
-        if (expect(json).to have_payload_key(attribute, options[:allow_nil])) == true
-          unless options[:allow_nil]
-            output = instance_exec(record, &prc)
-            expect(json[attribute.to_s]).to match_payload(attribute, output)
-
-            if options[:type]
-              expect(json[attribute.to_s]).to match_type(attribute, options[:type])
-            end
-          end
-        end
-      end
-
-      payload.no_keys.each do |no_key|
-        expect(json).to_not have_payload_key(no_key, {})
-      end
-
-      unexpected_keys = json.keys - payload.keys.keys.map(&:to_s)
-      unexpected_keys.reject! { |k| %w(id jsonapi_type).include?(k) }
-      unexpected_keys.each do |key|
-        expect(key).to be_not_in_payload
-      end
+    def errors
+      jsonapi_errors
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi_spec_helpers
 version: !ruby/object:Gem::Version
-  version: 0.4.10
+  version: 1.0.alpha.2
 platform: ruby
 authors:
 - Lee Richmond
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-28 00:00:00.000000000 Z
+date: 2018-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: jsonapi_compliable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.alpha.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.alpha.1
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -114,10 +128,10 @@ files:
 - jsonapi_spec_helpers.gemspec
 - lib/jsonapi_spec_helpers.rb
 - lib/jsonapi_spec_helpers/errors.rb
+- lib/jsonapi_spec_helpers/errors_proxy.rb
 - lib/jsonapi_spec_helpers/helpers.rb
-- lib/jsonapi_spec_helpers/matchers.rb
-- lib/jsonapi_spec_helpers/payload.rb
-- lib/jsonapi_spec_helpers/payload_sanitizer.rb
+- lib/jsonapi_spec_helpers/node.rb
+- lib/jsonapi_spec_helpers/rspec.rb
 - lib/jsonapi_spec_helpers/version.rb
 homepage: 
 licenses:
@@ -134,12 +148,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Spec helpers for jsonapi

data/lib/jsonapi_spec_helpers/matchers.rb

@@ -1,61 +0,0 @@
-require 'rspec/matchers'
-
-RSpec::Matchers.define :match_payload do |attribute, expected|
-  match do |actual|
-    if expected.respond_to?(:as_json)
-      expected = expected.as_json
-    end
-
-    actual == expected
-  end
-
-  failure_message do |actual|
-    "Expected JSON payload to have key '#{attribute}' == #{expected.inspect} but was #{actual.inspect}"
-  end
-end
-
-RSpec::Matchers.define :match_type do |attribute, type|
-  match do |actual|
-    if type.is_a?(Array)
-      type.any? { |t| actual.is_a?(t) }
-    else
-      actual.is_a?(type)
-    end
-  end
-
-  failure_message do |actual|
-    "Expected JSON payload key '#{attribute}' to have type #{type} but was #{actual.class}"
-  end
-end
-
-RSpec::Matchers.define :have_payload_key do |expected, allow_nil|
-  match do |json|
-    @has_key = json.has_key?(expected.to_s)
-    @has_value = !json[expected.to_s].nil?
-
-    if allow_nil
-      @has_key
-    else
-      @has_key && @has_value
-    end
-  end
-
-  failure_message do |actual|
-    msg = !allow_nil && @has_key ? "nil. Use 'key(:foo, allow_nil: true)' to allow nils" : "not present"
-    "Expected JSON payload to have key '#{expected}' but was #{msg}"
-  end
-
-  failure_message_when_negated do |actual|
-    "Expected JSON payload to NOT have key '#{expected}' but was present"
-  end
-end
-
-RSpec::Matchers.define :be_not_in_payload do |expected|
-  match do |json|
-    false
-  end
-
-  failure_message do |actual|
-    "JSON payload contained unexpected key '#{actual}'"
-  end
-end

data/lib/jsonapi_spec_helpers/payload.rb

@@ -1,66 +0,0 @@
-module JsonapiSpecHelpers
-  class Payload
-    class << self
-      attr_accessor :registry
-    end
-    self.registry = {}
-
-    attr_accessor :name, :type, :keys, :no_keys
-
-    def self.register(name, &blk)
-      instance = new
-      instance.instance_eval(&blk)
-      instance.name = name
-      registry[name] = instance
-    end
-
-    def self.by_type(type)
-      found = nil
-      registry.each_pair do |name, payload|
-        found = payload if payload.type == type
-      end
-      raise "Could not find payload for type #{type}" unless found
-      found
-    end
-
-    def fork
-      instance = self.class.new
-      instance.keys = keys.dup
-      instance.no_keys = no_keys.dup
-      instance
-    end
-
-    def initialize
-      @keys = {}
-      @no_keys = []
-    end
-
-    def no_key(name)
-      @keys.delete(name)
-      @no_keys << name
-    end
-
-    def type(val = nil)
-      if val
-        @type = val
-      else
-        @type || name.to_s.pluralize.to_sym
-      end
-    end
-
-    def key(name, *args, &blk)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      options[:type] = args.first
-      options[:allow_nil] ||= false
-      @no_keys.reject! { |k| k == name }
-      prc = blk
-      prc = ->(record) { record.send(name) } if prc.nil?
-      @keys[name] = options.merge(proc: prc)
-    end
-
-    def timestamps!
-      @keys[:created_at] = key(:created_at, String)
-      @keys[:updated_at] = key(:updated_at, String)
-    end
-  end
-end

data/lib/jsonapi_spec_helpers/payload_sanitizer.rb

@@ -1,93 +0,0 @@
-module JsonapiSpecHelpers
-  class PayloadSanitizer
-    def initialize(payload)
-      @payload = payload
-      @included = []
-    end
-
-    def resource
-      @resource ||= sane_resource(@payload)
-    end
-
-    def sanitize
-      resource[:relationships].each_pair do |key, relationship_payload|
-        set_default_relationship_payload(key, relationship_payload)
-
-        if relationship_payload.is_a?(Array)
-          relationship_payload.each do |p|
-            process_relationship(key, p)
-          end
-        else
-          process_relationship(key, relationship_payload)
-        end
-      end
-
-      payload = { data: data }
-      payload[:included] = @included
-      payload
-    end
-
-    def included
-      @included
-    end
-
-    def add_include(incl)
-      @included.push(incl) if @included.index(incl).nil?
-    end
-
-    def resource_identifier
-      {}.tap do |ri|
-        ri[:id]   = resource[:id] if resource[:id]
-        ri[:type] = resource[:type]
-      end
-    end
-
-    def data
-      @data ||= {}.tap do |d|
-        d[:id]         = resource[:id] if resource[:id]
-        d[:type]       = resource[:type]
-        d[:attributes] = resource[:attributes]
-      end
-    end
-
-    private
-
-    def set_default_relationship_payload(key, payload)
-      data[:relationships] ||= {}
-      if payload.is_a?(Array)
-        data[:relationships][key] ||= { data: [] }
-      else
-        data[:relationships][key] ||= { data: nil }
-      end
-    end
-
-    def process_relationship(name, relationship_payload)
-      sanitizer = self.class.new(relationship_payload)
-
-      if data[:relationships][name][:data].is_a?(Array)
-        data[:relationships][name][:data] << sanitizer.resource_identifier
-      else
-        data[:relationships][name] = { data: sanitizer.resource_identifier }
-      end
-
-      sanitized = sanitizer.sanitize
-      add_include(sanitized[:data])
-      sanitized[:included].each do |incl|
-        add_include(incl)
-      end
-    end
-
-    def sane_resource(payload)
-      id, type = payload.delete(:id), payload.delete(:type)
-      relationships = payload.delete(:relationships) || {}
-      raise 'jsonapi payloads must specify a "type"' if type.nil?
-
-      {
-        id: id,
-        type: type,
-        attributes: payload,
-        relationships: relationships
-      }
-    end
-  end
-end