simple_jsonapi 1.0.0

data/test/parameters/include_spec_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+class IncludeSpecTest < Minitest::Spec
+  describe SimpleJsonapi::Parameters::IncludeSpec do
+    describe "parsing" do
+      it "accepts a comma-delimited list" do
+        spec = SimpleJsonapi::Parameters::IncludeSpec.new("order,product")
+        assert_equal({ order: {}, product: {} }, spec.to_h)
+      end
+
+      it "accepts a list of strings" do
+        spec = SimpleJsonapi::Parameters::IncludeSpec.new("order", "product")
+        assert_equal({ order: {}, product: {} }, spec.to_h)
+      end
+
+      it "accepts an array of strings" do
+        spec = SimpleJsonapi::Parameters::IncludeSpec.new(["order", "product"])
+        assert_equal({ order: {}, product: {} }, spec.to_h)
+      end
+    end
+
+    describe "nested includes" do
+      let(:nested_spec) do
+        SimpleJsonapi::Parameters::IncludeSpec.new(
+          "rel_1",
+          "rel_1.rel_1_a",
+          "rel_1.rel_1_a.rel_1_a_i",
+          "rel_1.rel_1_a.rel_1_a_ii",
+          "rel_1.rel_1_b",
+        )
+      end
+
+      it "parses nested includes" do
+        expected_value = {
+          rel_1: {
+            rel_1_a: {
+              rel_1_a_i: {},
+              rel_1_a_ii: {},
+            },
+            rel_1_b: {},
+          },
+        }
+        assert_equal(expected_value, nested_spec.to_h)
+      end
+
+      it "extracts a nested include spec" do
+        expected_value = {
+          rel_1_a: {
+            rel_1_a_i: {},
+            rel_1_a_ii: {},
+          },
+          rel_1_b: {},
+        }
+        assert_equal(expected_value, nested_spec[:rel_1].to_h)
+      end
+    end
+  end
+end

data/test/parameters/sort_spec_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+class SortSpecTest < Minitest::Spec
+  describe SimpleJsonapi::Parameters::SortSpec do
+    it "interprets a field name as ascending" do
+      spec = SimpleJsonapi::Parameters::SortSpec.new("orders" => "customer_name")
+
+      assert_equal [:customer_name], spec[:orders].map(&:field)
+      assert_equal [:asc], spec[:orders].map(&:dir)
+    end
+
+    it "interprets a leading hyphen as descending" do
+      spec = SimpleJsonapi::Parameters::SortSpec.new("orders" => "-customer_name")
+
+      assert_equal [:customer_name], spec[:orders].map(&:field)
+      assert_equal [:desc], spec[:orders].map(&:dir)
+    end
+
+    it "accepts comma-delimited strings" do
+      spec = SimpleJsonapi::Parameters::SortSpec.new(
+        "orders" => "customer_name,-description",
+        "line_items" => "-order_id,product_id",
+      )
+
+      assert_equal [:customer_name, :description], spec[:orders].map(&:field)
+      assert_equal [:asc, :desc], spec[:orders].map(&:dir)
+
+      assert_equal [:order_id, :product_id], spec[:line_items].map(&:field)
+      assert_equal [:desc, :asc], spec[:line_items].map(&:dir)
+    end
+
+    it "accepts arrays of strings" do
+      spec = SimpleJsonapi::Parameters::SortSpec.new(
+        "orders" => ["customer_name", "-description"],
+        "line_items" => ["-order_id", "product_id"],
+      )
+
+      assert_equal [:customer_name, :description], spec[:orders].map(&:field)
+      assert_equal [:asc, :desc], spec[:orders].map(&:dir)
+
+      assert_equal [:order_id, :product_id], spec[:line_items].map(&:field)
+      assert_equal [:desc, :asc], spec[:line_items].map(&:dir)
+    end
+  end
+
+  describe SimpleJsonapi::Parameters::SortFieldSpec do
+    it "interprets a field name as ascending" do
+      field_spec = SimpleJsonapi::Parameters::SortFieldSpec.new("customer_name")
+
+      assert_equal :customer_name, field_spec.field
+      assert_equal :asc, field_spec.dir
+      assert_equal true, field_spec.asc?
+      assert_equal false, field_spec.desc?
+    end
+
+    it "interprets a leading hyphen as descending" do
+      field_spec = SimpleJsonapi::Parameters::SortFieldSpec.new("-customer_name")
+
+      assert_equal :customer_name, field_spec.field
+      assert_equal :desc, field_spec.dir
+      assert_equal false, field_spec.asc?
+      assert_equal true, field_spec.desc?
+    end
+  end
+end

data/test/resources/attributes_test.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+
+class AttributesTest < Minitest::Spec
+  class Thing < TestModel
+    attr_accessor :name, :number, :timestamp
+  end
+
+  describe "Resource attributes" do
+    describe "rendering" do
+      class BasicSerializer < SimpleJsonapi::Serializer
+        attribute :name
+        attribute(:number) { |res| res.number&.to_i }
+        attribute(:date) { |res| res.timestamp&.to_date&.iso8601 }
+      end
+
+      let(:thing) do
+        Thing.new(
+          id: 1,
+          name: "Thing 1",
+          number: 2.718,
+          timestamp: Time.new(2017, 7, 15, 12, 34, 56),
+        )
+      end
+
+      let(:serialized) { SimpleJsonapi.render_resource(thing, serializer: BasicSerializer) }
+      let(:attributes) { serialized.dig(:data, :attributes) }
+
+      it "calls the matching method by default" do
+        assert_equal "Thing 1", attributes[:name]
+      end
+
+      it "executes a proc" do
+        assert_equal 2, attributes[:number]
+      end
+    end
+
+    describe "conditional rendering" do
+      class ConditionalSerializer < SimpleJsonapi::Serializer
+        attribute :name, if: ->(res) { res.name.starts_with?("A") }
+        attribute :number, unless: ->(res) { res.name.starts_with?("Z") }
+        attribute(:date) { |res| res.timestamp&.to_date&.iso8601 }
+      end
+
+      let(:thing_a) { Thing.new(id: 1, name: "Abigail", number: 123) }
+      let(:thing_z) { Thing.new(id: 2, name: "Zachary", number: 456) }
+
+      def attributes_for(thing)
+        SimpleJsonapi.render_resource(thing, serializer: ConditionalSerializer).dig(:data, :attributes)
+      end
+
+      it "renders the attribute when the 'if' is truthy" do
+        assert_equal "Abigail", attributes_for(thing_a)[:name]
+      end
+
+      it "renders the attribute when the 'unless' is falsey" do
+        assert_equal 123, attributes_for(thing_a)[:number]
+      end
+
+      it "omits the attribute when the 'if' is falsey" do
+        refute_includes attributes_for(thing_z).keys, :name
+      end
+
+      it "omits the attribute when the 'unless' is truthy" do
+        refute_includes attributes_for(thing_z).keys, :number
+      end
+    end
+
+    describe "validation" do
+      it "cannot be named id" do
+        assert_raises(ArgumentError) do
+          Class.new(SimpleJsonapi::Serializer) { attribute :id }
+        end
+      end
+
+      it "cannot be named type" do
+        assert_raises(ArgumentError) do
+          Class.new(SimpleJsonapi::Serializer) { attribute :type }
+        end
+      end
+    end
+
+    describe "documentation" do
+      class DocSerializer < SimpleJsonapi::Serializer
+        attribute :name
+        attribute :number, type: :numeric, description: "a number"
+        attribute :colors, type: :string, array: true
+      end
+
+      it "builds an attribute without documentation" do
+        attr_defn = DocSerializer.definition.attribute_definitions[:name]
+        assert_nil attr_defn.data_type
+        assert_equal false, attr_defn.array
+        assert_nil attr_defn.description
+      end
+
+      it "stores the type and description" do
+        attr_defn = DocSerializer.definition.attribute_definitions[:number]
+        assert_equal :numeric, attr_defn.data_type
+        assert_equal "a number", attr_defn.description
+      end
+
+      it "stores the type and array-ness" do
+        attr_defn = DocSerializer.definition.attribute_definitions[:colors]
+        assert_equal :string, attr_defn.data_type
+        assert_equal true, attr_defn.array
+      end
+    end
+  end
+end

data/test/resources/extras_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+class ExtrasTest < Minitest::Spec
+  class Order < TestModel
+    attr_accessor :order_number, :total_price, :customer
+  end
+
+  class Customer < TestModel
+    attr_accessor :first_name, :last_name
+  end
+
+  class OrderSerializer < SimpleJsonapi::Serializer
+    attribute(:order_number) { |_order| @override_order_number }
+    attribute(:total_price) { |_order| @override_total_price }
+    has_one :customer, if: ->(_order) { @has_a_customer }
+  end
+
+  class CustomerSerializer < SimpleJsonapi::Serializer
+    attribute(:first_name) { |_customer| @override_first_name }
+    attribute(:last_name) { |_customer| @override_last_name }
+  end
+
+  let(:order) { Order.new(id: 1, order_number: "123", total_price: "5.99", customer: customer) }
+  let(:customer) { Customer.new(id: 2, first_name: "Andrei", last_name: "Romanov") }
+
+  describe "Extra contextual data" do
+    describe "on the root resource" do
+      it "runs when no extras are provided" do
+        serialized = SimpleJsonapi.render_resource(order)
+        assert_nil serialized.dig(:data, :attributes, :order_number)
+      end
+
+      it "makes the extras hash available to the attributes" do
+        serialized = SimpleJsonapi.render_resource(
+          order,
+          extras: {
+            override_order_number: "999",
+            override_total_price: 1.00,
+          },
+        )
+        assert_equal "999", serialized.dig(:data, :attributes, :order_number)
+        assert_equal 1.00, serialized.dig(:data, :attributes, :total_price)
+      end
+
+      it "makes the extras hash available to an if predicate" do
+        serialized = SimpleJsonapi.render_resource(order, extras: { has_a_customer: false })
+        assert_nil serialized.dig(:data, :relationships, :customer, :data)
+
+        serialized = SimpleJsonapi.render_resource(order, extras: { has_a_customer: true })
+        assert_equal "2", serialized.dig(:data, :relationships, :customer, :data, :id)
+      end
+    end
+
+    describe "on a related resource" do
+      it "makes the extras hash available to the attributes" do
+        serialized = SimpleJsonapi.render_resource(
+          order,
+          include: "customer",
+          extras: {
+            has_a_customer: true,
+            override_first_name: "Jane",
+            override_last_name: "Doe",
+          },
+        )
+        assert_equal "Jane", serialized.dig(:included, 0, :attributes, :first_name)
+        assert_equal "Doe", serialized.dig(:included, 0, :attributes, :last_name)
+      end
+    end
+  end
+end

data/test/resources/id_and_type_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+class IdAndTypeTest < Minitest::Spec
+  class Thing < TestModel
+  end
+
+  let(:thing) { Thing.new(id: 4) }
+
+  describe "Resource id and type" do
+    describe "default implementation" do
+      class DefaultsSerializer < SimpleJsonapi::Serializer
+      end
+
+      it "calls the id method" do
+        serialized = SimpleJsonapi.render_resource(thing, serializer: DefaultsSerializer)
+        assert_equal "4", serialized.dig(:data, :id)
+      end
+
+      it "uses the objects type" do
+        serialized = SimpleJsonapi.render_resource(thing, serializer: DefaultsSerializer)
+        assert_equal "things", serialized.dig(:data, :type)
+      end
+    end
+
+    describe "defined with blocks" do
+      class BlocksSerializer < SimpleJsonapi::Serializer
+        id { |thing| "#{thing.id}-the-thing" }
+        type { |thing| thing.class.name }
+      end
+
+      it "calls the block" do
+        serialized = SimpleJsonapi.render_resource(thing, serializer: BlocksSerializer)
+        assert_equal "4-the-thing", serialized.dig(:data, :id)
+      end
+
+      it "calls the block" do
+        serialized = SimpleJsonapi.render_resource(thing, serializer: BlocksSerializer)
+        assert_equal "IdAndTypeTest::Thing", serialized.dig(:data, :type)
+      end
+    end
+
+    describe "defined with procs" do
+      class ProcsSerializer < SimpleJsonapi::Serializer
+        id ->(thing) { "#{thing.id}-the-thing" }
+        type ->(thing) { thing.class.name }
+      end
+
+      it "calls the proc" do
+        serialized = SimpleJsonapi.render_resource(thing, serializer: ProcsSerializer)
+        assert_equal "4-the-thing", serialized.dig(:data, :id)
+      end
+
+      it "calls the proc" do
+        serialized = SimpleJsonapi.render_resource(thing, serializer: ProcsSerializer)
+        assert_equal "IdAndTypeTest::Thing", serialized.dig(:data, :type)
+      end
+    end
+
+    describe "defined with constant values" do
+      class ValuesSerializer < SimpleJsonapi::Serializer
+        id 42
+        type "values"
+      end
+
+      it "renders the value" do
+        serialized = SimpleJsonapi.render_resource(thing, serializer: ValuesSerializer)
+        assert_equal "42", serialized.dig(:data, :id)
+      end
+
+      it "renders the value" do
+        serialized = SimpleJsonapi.render_resource(thing, serializer: ValuesSerializer)
+        assert_equal "values", serialized.dig(:data, :type)
+      end
+    end
+  end
+end

data/test/resources/inclusion_test.rb

@@ -0,0 +1,134 @@
+require 'test_helper'
+
+class InclusionTest < Minitest::Spec
+  class Order < TestModel
+    attr_writer :line_items
+
+    def line_items
+      @line_items ||= []
+    end
+  end
+
+  class LineItem < TestModel
+    attr_accessor :product
+  end
+
+  class Product < TestModel
+  end
+
+  class OrderSerializer < SimpleJsonapi::Serializer
+    has_many :line_items do
+      data(&:line_items)
+    end
+    has_many :products do
+      data { |o| o.line_items.flat_map(&:product).compact.uniq }
+    end
+  end
+
+  class LineItemSerializer < SimpleJsonapi::Serializer
+    has_one :product do
+      data(&:product)
+    end
+  end
+
+  class ProductSerializer < SimpleJsonapi::Serializer
+  end
+
+  let(:order) { Order.new(id: 10, line_items: [line_item]) }
+  let(:line_item) { LineItem.new(id: 20, product: product) }
+  let(:product) { Product.new(id: 30) }
+
+  let(:included_line_item) do
+    serialized[:included]&.find { |res| res[:type] == "line_items" }
+  end
+  let(:included_product) do
+    serialized[:included]&.find { |res| res[:type] == "products" }
+  end
+
+  # def meta_for_resource(resource, relationship_name)
+  #   resource.dig(:relationships, relationship_name, :data, :meta)
+  # end
+
+  describe "Including related resources" do
+    describe "without an include parameter" do
+      let(:serialized) { SimpleJsonapi.render_resource(order) }
+
+      it "doesn't include any related resources" do
+        refute serialized.key?(:included)
+      end
+
+      it "adds meta information to the root resource" do
+        assert_equal(
+          { included: false },
+          serialized.dig(:data, :relationships, :line_items, :data, 0, :meta) # has_many
+        )
+      end
+    end
+
+    describe "with one level of inclusion" do
+      let(:serialized) do
+        SimpleJsonapi.render_resource(order, include: "line_items")
+      end
+
+      it "includes the related resources" do
+        refute_nil included_line_item
+        assert_nil included_product
+      end
+
+      it "adds meta information to the root resource" do
+        assert_equal(
+          { included: true },
+          serialized.dig(:data, :relationships, :line_items, :data, 0, :meta) # has_many
+        )
+      end
+
+      it "adds meta information to the included resource" do
+        assert_equal(
+          { included: false },
+          included_line_item.dig(:relationships, :product, :data, :meta) # has_one
+        )
+      end
+    end
+
+    describe "with two levels of inclusion" do
+      let(:serialized) do
+        SimpleJsonapi.render_resource(order, include: "line_items,line_items.product")
+      end
+
+      it "includes the related resources" do
+        refute_nil included_line_item
+        refute_nil included_product
+      end
+
+      it "adds meta information to the base resource" do
+        assert_equal(
+          { included: true },
+          serialized.dig(:data, :relationships, :line_items, :data, 0, :meta) # has_many
+        )
+      end
+
+      it "adds meta information to the included resource" do
+        assert_equal(
+          { included: true },
+          included_line_item.dig(:relationships, :product, :data, :meta) # has_one
+        )
+      end
+    end
+
+    describe "duplicate resources" do
+      let(:serialized) do
+        SimpleJsonapi.render_resource(order, include: "line_items,line_items.product,products")
+      end
+
+      it "includes the related object only once" do
+        order_to_products_linkage = serialized.dig(:data, :relationships, :products, :data, 0) # has_many
+        line_item_to_product_linkage = included_line_item.dig(:relationships, :product, :data) # has_one
+
+        assert_equal product.id.to_s, order_to_products_linkage[:id]
+        assert_equal product.id.to_s, line_item_to_product_linkage[:id]
+
+        assert_equal(1, serialized[:included].count { |res| res[:type] == "products" })
+      end
+    end
+  end
+end