require "test_helper"

class AssociationTest < ActiveModel::TestCase
  def def_serializer(&block)
    Class.new(ActiveModel::Serializer, &block)
  end

  class Model
    def initialize(hash={})
      @attributes = hash
    end

    def read_attribute_for_serialization(name)
      @attributes[name]
    end

    def as_json(*)
      { :model => "Model" }
    end

    def method_missing(meth, *args)
      if meth.to_s =~ /^(.*)=$/
        @attributes[$1.to_sym] = args[0]
      elsif @attributes.key?(meth)
        @attributes[meth]
      else
        super
      end
    end
  end

  def setup
    @hash = {}
    @root_hash = {}

    @post = Model.new(:title => "New Post", :body => "Body")
    @comment = Model.new(:id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT")
    @post.comments = [ @comment ]
    @post.comment = @comment

    @comment_serializer_class = def_serializer do
      attributes :id, :external_id, :body
    end

    @post_serializer_class = def_serializer do
      attributes :title, :body
    end

    @post_serializer = @post_serializer_class.new(@post, :hash => @root_hash)
  end

  def include!(key, options={})
    @post_serializer.include! key, {
      :embed => :ids,
      :include => true,
      :node => @hash,
      :serializer => @comment_serializer_class
    }.merge(options)
  end

  def include_bare!(key, options={})
    @post_serializer.include! key, {
      :node => @hash,
      :serializer => @comment_serializer_class
    }.merge(options)
  end

  class NoDefaults < AssociationTest
    def test_include_bang_has_many_associations
      include! :comments, :value => @post.comments

      assert_equal({
        :comment_ids => [ 1 ]
      }, @hash)

      assert_equal({
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, @root_hash)
    end

    def test_include_bang_with_embed_false
      include! :comments, :value => @post.comments, :embed => false

      assert_equal({}, @hash)
      assert_equal({}, @root_hash)
    end

    def test_include_bang_with_embed_ids_include_false
      include! :comments, :value => @post.comments, :embed => :ids, :include => false

      assert_equal({
        :comment_ids => [ 1 ]
      }, @hash)

      assert_equal({}, @root_hash)
    end

    def test_include_bang_has_one_associations
      include! :comment, :value => @post.comment

      assert_equal({
        :comment_id => 1
      }, @hash)

      assert_equal({
        :comments => [{ :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }]
      }, @root_hash)
    end
  end

  class DefaultsTest < AssociationTest
    def test_with_default_has_many
      @post_serializer_class.class_eval do
        has_many :comments
      end

      include! :comments

      assert_equal({
        :comment_ids => [ 1 ]
      }, @hash)

      assert_equal({
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, @root_hash)
    end

    def test_with_default_has_one
      @post_serializer_class.class_eval do
        has_one :comment
      end

      include! :comment

      assert_equal({
        :comment_id => 1
      }, @hash)

      assert_equal({
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, @root_hash)
    end

    def test_with_default_has_many_with_custom_key
      @post_serializer_class.class_eval do
        has_many :comments, :key => :custom_comments
      end

      include! :comments

      assert_equal({
        :custom_comments => [ 1 ]
      }, @hash)

      assert_equal({
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, @root_hash)
    end

    def test_with_default_has_one_with_custom_key
      @post_serializer_class.class_eval do
        has_one :comment, :key => :custom_comment_id
      end

      include! :comment

      assert_equal({
        :custom_comment_id => 1
      }, @hash)

      assert_equal({
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, @root_hash)
    end

    def test_with_default_has_many_with_custom_embed_key
      @post_serializer_class.class_eval do
        has_many :comments, :embed_key => :external_id
      end

      include! :comments

      assert_equal({
        :comment_ids => [ "COMM001" ]
      }, @hash)

      assert_equal({
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, @root_hash)
    end

    def test_with_default_has_one_with_custom_embed_key
      @post_serializer_class.class_eval do
        has_one :comment, :embed_key => :external_id
      end

      include! :comment

      assert_equal({
        :comment_id => "COMM001"
      }, @hash)

      assert_equal({
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, @root_hash)
    end

    def test_with_default_has_many_with_custom_key_and_custom_embed_key
      @post_serializer_class.class_eval do
        has_many :comments, :key => :custom_comments, :embed_key => :external_id
      end

      include! :comments

      assert_equal({
        :custom_comments => [ "COMM001" ]
      }, @hash)

      assert_equal({
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, @root_hash)
    end

    def test_with_default_has_one_with_custom_key_and_custom_embed_key
      @post_serializer_class.class_eval do
        has_one :comment, :key => :custom_comment, :embed_key => :external_id
      end

      include! :comment

      assert_equal({
        :custom_comment => "COMM001"
      }, @hash)

      assert_equal({
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, @root_hash)
    end

    def test_embed_objects_for_has_many_associations
      @post_serializer_class.class_eval do
        has_many :comments, :embed => :objects
      end

      include_bare! :comments

      assert_equal({
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, @hash)

      assert_equal({}, @root_hash)
    end

    def test_embed_ids_for_has_many_associations
      @post_serializer_class.class_eval do
        has_many :comments, :embed => :ids
      end

      include_bare! :comments

      assert_equal({
        :comment_ids => [ 1 ]
      }, @hash)

      assert_equal({}, @root_hash)
    end

    def test_embed_false_for_has_many_associations
      @post_serializer_class.class_eval do
        has_many :comments, :embed => false
      end

      include_bare! :comments

      assert_equal({}, @hash)
      assert_equal({}, @root_hash)
    end

    def test_embed_ids_include_true_for_has_many_associations
      @post_serializer_class.class_eval do
        has_many :comments, :embed => :ids, :include => true
      end

      include_bare! :comments

      assert_equal({
        :comment_ids => [ 1 ]
      }, @hash)

      assert_equal({
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, @root_hash)
    end

    def test_embed_ids_for_has_one_associations
      @post_serializer_class.class_eval do
        has_one :comment, :embed => :ids
      end

      include_bare! :comment

      assert_equal({
        :comment_id => 1
      }, @hash)

      assert_equal({}, @root_hash)
    end

    def test_embed_false_for_has_one_associations
      @post_serializer_class.class_eval do
        has_one :comment, :embed => false
      end

      include_bare! :comment

      assert_equal({}, @hash)
      assert_equal({}, @root_hash)
    end

    def test_embed_ids_include_true_for_has_one_associations
      @post_serializer_class.class_eval do
        has_one :comment, :embed => :ids, :include => true
      end

      include_bare! :comment

      assert_equal({
        :comment_id => 1
      }, @hash)

      assert_equal({
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, @root_hash)
    end

    def test_embed_ids_include_true_does_not_serialize_multiple_times
      @post.recent_comment = @comment

      @post_serializer_class.class_eval do
        has_one :comment, :embed => :ids, :include => true
        has_one :recent_comment, :embed => :ids, :include => true, :root => :comments
      end

      # Count how often the @comment record is serialized.
      serialized_times = 0
      @comment.class_eval do
        define_method :read_attribute_for_serialization, lambda { |name|
          serialized_times += 1 if name == :body
          super(name)
        }
      end

      include_bare! :comment
      include_bare! :recent_comment

      assert_equal 1, serialized_times
    end

    def test_include_with_read_association_id_for_serialization_hook
      @post_serializer_class.class_eval do
        has_one :comment, :embed => :ids, :include => true
      end

      association_name = nil
      @post.class_eval do
        define_method :read_attribute_for_serialization, lambda { |name|
          association_name = name
          send(name)
        }
        define_method :comment_id, lambda {
          @attributes[:comment].id
        }
      end

      include_bare! :comment

      assert_equal({
        :comment_id => 1
      }, @hash)
    end

    def test_include_with_read_association_ids_for_serialization_hook
      @post_serializer_class.class_eval do
        has_many :comments, :embed => :ids, :include => false
      end

      association_name = nil
      @post.class_eval do
        define_method :read_attribute_for_serialization, lambda { |name|
          association_name = name
          send(name)
        }
        define_method :comment_ids, lambda {
          @attributes[:comments].map(&:id)
        }
      end

      include_bare! :comments

      assert_equal({
        :comment_ids => [1]
      }, @hash)
    end
  end

  class RecursiveTest < AssociationTest
    class BarSerializer < ActiveModel::Serializer; end

    class FooSerializer < ActiveModel::Serializer
      root :foos
      attributes :id
      has_many :bars, :serializer => BarSerializer, :root => :bars, :embed => :ids, :include => true
    end

    class BarSerializer < ActiveModel::Serializer
      root :bars
      attributes :id
      has_many :foos, :serializer => FooSerializer, :root => :foos, :embed => :ids, :include => true
    end

    class Foo < Model
      def active_model_serializer; FooSerializer; end
    end

    class Bar < Model
      def active_model_serializer; BarSerializer; end
    end

    def setup
      super

      foo = Foo.new(:id => 1)
      bar = Bar.new(:id => 2)

      foo.bars = [ bar ]
      bar.foos = [ foo ]

      collection = [ foo ]

      @serializer = collection.active_model_serializer.new(collection, :root => :foos)
    end

    def test_mutual_relation_result
      assert_equal({
        :foos => [{
          :bar_ids => [ 2 ],
          :id => 1
        }],
        :bars => [{
          :foo_ids => [ 1 ],
          :id => 2
        }]
      }, @serializer.as_json)
    end

    def test_mutual_relation_does_not_raise_error
      assert_nothing_raised SystemStackError, 'stack level too deep' do
        @serializer.as_json
      end
    end
  end

  class InclusionTest < AssociationTest
    def setup
      super

      comment_serializer_class = @comment_serializer_class

      @post_serializer_class.class_eval do
        root :post
        embed :ids, :include => true
        has_many :comments, :serializer => comment_serializer_class
      end
    end

    def test_when_it_is_included
      post_serializer = @post_serializer_class.new(
        @post, :include => [:comments]
      )

      json = post_serializer.as_json

      assert_equal({
        :post => {
          :title => "New Post",
          :body => "Body",
          :comment_ids => [ 1 ]
        },
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, json)
    end

    def test_when_it_is_not_included
      post_serializer = @post_serializer_class.new(
        @post, :include => []
      )

      json = post_serializer.as_json

      assert_equal({
        :post => {
          :title => "New Post",
          :body => "Body",
          :comment_ids => [ 1 ]
        }
      }, json)
    end

    def test_when_it_is_excluded
      post_serializer = @post_serializer_class.new(
        @post, :exclude => [:comments]
      )

      json = post_serializer.as_json

      assert_equal({
        :post => {
          :title => "New Post",
          :body => "Body",
          :comment_ids => [ 1 ]
        }
      }, json)
    end

    def test_when_it_is_not_excluded
      post_serializer = @post_serializer_class.new(
        @post, :exclude => []
      )

      json = post_serializer.as_json

      assert_equal({
        :post => {
          :title => "New Post",
          :body => "Body",
          :comment_ids => [ 1 ]
        },
        :comments => [
          { :id => 1, :external_id => "COMM001", :body => "ZOMG A COMMENT" }
        ]
      }, json)
    end
  end

  class StringSerializerOption < AssociationTest
    class StringSerializer < ActiveModel::Serializer
      attributes :id, :body
    end

    def test_specifying_serializer_class_as_string
      @post_serializer_class.class_eval do
        has_many :comments, :embed => :objects
      end

      include_bare! :comments, :serializer => "AssociationTest::StringSerializerOption::StringSerializer"

      assert_equal({
        :comments => [
          { :id => 1, :body => "ZOMG A COMMENT" }
        ]
      }, @hash)

      assert_equal({}, @root_hash)
    end
  end
end