daylight 0.9.0.rc1

data/spec/rails/extensions/array_ext_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+class NonExtractableTest < Hash; end
+
+class IsExtractableTest < Hash
+  def extractable_options?
+    true
+  end
+end
+
+describe Array do
+  describe :extract_options do
+    it 'returns options' do
+      [foo: 'bar'].extract_options.should == {foo: 'bar'}
+      ['a', foo: 'bar'].extract_options.should == {foo: 'bar'}
+    end
+
+    it 'returns empty hash when no options' do
+      [].extract_options.should == {}
+      ['a', 'b'].extract_options.should == {}
+    end
+
+    it 'returns empty hash when not extractable' do
+      hash = NonExtractableTest.new
+      hash[:foo] = 'bar'
+      [hash].extract_options.should == {}
+    end
+
+    it 'returns extractable hash when extractable' do
+      test = IsExtractableTest.new
+      test[:foo] = 'bar'
+      [test].extract_options.should == test
+    end
+
+    it 'leaves options on arguments' do
+      hash = [foo: 'bar']
+      hash.extract_options
+      hash.should ==  [foo: 'bar']
+
+      hash = ['a', foo: 'bar']
+      hash.extract_options
+      hash.should ==  ['a', foo: 'bar']
+
+      test = IsExtractableTest.new
+      test[:foo] = 'bar'
+      hash = [test]
+      hash.extract_options
+      hash.should == [test]
+    end
+  end
+end

data/spec/rails/extensions/has_one_serializer_ext_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+class HasOneSerializerTest < ActiveRecord::Base
+  belongs_to :associated_test
+  has_one    :associated_through_test, through: :associated_test
+end
+
+class AssociatedTest < ActiveRecord::Base
+  belongs_to :associated_through_test
+end
+
+class AssociatedThroughTest < ActiveRecord::Base
+end
+
+class HasOneSerializerTestController < ActionController::Base
+  # The read_only values will be activated based on Serializer
+  def show
+    render json: HasOneSerializerTest.find(params[:id])
+  end
+
+  def embed
+    render json: HasOneSerializerTest.find(params[:id]),
+           serializer: EmbedHasOneSerializerTestSerializer
+  end
+end
+
+class HasOneSerializerTestSerializer < ActiveModel::Serializer
+  embed :ids
+
+  has_one :associated_test                                      # tests orginal
+  has_one :associated_through_test, through: :associated_test   # tests through
+end
+
+class EmbedHasOneSerializerTestSerializer < ActiveModel::Serializer
+  has_one :associated_test                                      # tests orginal
+  has_one :associated_through_test, through: :associated_test   # tests through
+end
+
+describe HasOneSerializerExt, type: [:controller, :routing] do
+
+  def self.controller_class
+    HasOneSerializerTestController
+  end
+
+  migrate do
+    create_table :has_one_serializer_tests do |t|
+      t.integer :associated_test_id
+    end
+
+    create_table :associated_tests do |t|
+      t.integer :associated_through_test_id
+    end
+
+    create_table :associated_through_tests do |t|
+      t.string :name
+    end
+  end
+
+  before do
+    @routes.draw do
+      resources :has_one_serializer_test do
+        get 'embed', on: :member
+      end
+    end
+  end
+
+  before :all do
+    FactoryGirl.define do
+      factory :has_one_serializer_test do
+        associated_test
+      end
+
+      factory :associated_test do
+        associated_through_test
+      end
+
+      factory :associated_through_test do
+        name { Faker::Name.name }
+      end
+    end
+  end
+
+  after :all do
+    Rails.application.reload_routes!
+  end
+
+  let!(:record) { create(:has_one_serializer_test) }
+
+  #
+  # embed id
+  #
+
+  it 'includes association id' do
+    get :show, id: record.id
+
+    json = JSON.parse(response.body)['has_one_serializer_test']
+    json['associated_test_id'].should == record.associated_test_id
+    json.keys.should_not include('associated_through_test_id')
+  end
+
+  it 'includes through association hash with ids' do
+    get :show, id: record.id
+
+    json = JSON.parse(response.body)['has_one_serializer_test']
+    json['associated_test_attributes'].should == {
+      'id'                         => record.associated_test.id,
+      'associated_through_test_id' => record.associated_test.associated_through_test_id
+    }
+  end
+
+  #
+  # embed object
+  #
+
+  it 'includes association' do
+    get :embed, id: record.id
+
+    json = JSON.parse(response.body)['embed_has_one_serializer_test']
+    json['associated_test'].should == record.associated_test.attributes
+  end
+
+  it 'includes association hash' do
+    get :embed, id: record.id
+
+    json = JSON.parse(response.body)['embed_has_one_serializer_test']
+    json['associated_test_attributes'].should == {
+      'id'                                 => record.associated_test.id,
+      'associated_through_test_id'         => record.associated_test.associated_through_test_id,
+      'associated_through_test_attributes' => {
+        'id'   => record.associated_test.associated_through_test.id,
+        'name' => record.associated_test.associated_through_test.name,
+      }
+    }
+  end
+end

data/spec/rails/extensions/nested_attributes_ext_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+class NoNestedAttributesTest < ActiveRecord::Base; end
+
+# `inverse_of` and `accepts_nested_attributes_for` both need to be defined to
+# test cyclic autosave problem that AutosaveAssociataionFix resolves
+class NestedAttributeTest < ActiveRecord::Base
+  has_many :collection, class_name: 'AssocNestedAttributeTest', inverse_of: :nested_attribute_test
+
+  accepts_nested_attributes_for :collection
+end
+
+class SingleNestedAttributeTest < ActiveRecord::Base
+  has_one :single, class_name: 'AssocNestedAttributeTest', inverse_of: :single_nested_attribute_test
+
+  accepts_nested_attributes_for :single, allow_destroy: true # with options
+end
+
+class AssocNestedAttributeTest < ActiveRecord::Base
+  belongs_to :nested_attribute_test, inverse_of: :collection
+  belongs_to :single_nested_attribute_test, inverse_of: :single
+
+  accepts_nested_attributes_for :nested_attribute_test, :single_nested_attribute_test
+end
+
+describe NestedAttributesExt, type: [:model] do
+
+  migrate do
+    create_table :nested_attribute_tests do |t|
+      t.string :name
+    end
+
+    create_table :single_nested_attribute_tests do |t|
+      t.string :name
+    end
+
+    create_table :assoc_nested_attribute_tests do |t|
+      t.string     :name
+      t.references :nested_attribute_test
+      t.references :single_nested_attribute_test
+    end
+  end
+
+  before(:all) do
+    FactoryGirl.define do
+      factory :nested_attribute_test do
+        name { Faker::Name.name }
+      end
+
+      factory :single_nested_attribute_test do
+        name { Faker::Name.name }
+      end
+
+      factory :assoc_nested_attribute_test do
+        name { Faker::Name.name }
+      end
+    end
+  end
+
+  describe 'nested_resource_names' do
+    it 'has empty array of no nested resources are configured' do
+      NoNestedAttributesTest.nested_resource_names.should == []
+      NoNestedAttributesTest.nested_resource_names.should be_frozen
+    end
+
+    it 'stores only nested resource names' do
+      SingleNestedAttributeTest.nested_resource_names.should == [:single]
+      SingleNestedAttributeTest.nested_resource_names.should be_frozen
+
+      AssocNestedAttributeTest.nested_resource_names.should == [:nested_attribute_test, :single_nested_attribute_test]
+      AssocNestedAttributeTest.nested_resource_names.should be_frozen
+    end
+
+    it 'propogates and updates nested attribute options' do
+      SingleNestedAttributeTest.nested_attributes_options.should == {single: {allow_destroy: true, update_only: false}}
+    end
+  end
+
+
+  describe 'has_many' do
+    let(:record) { create(:nested_attribute_test) }
+    let(:member) { create(:assoc_nested_attribute_test) }
+
+    it "ignores nil values" do
+      record.collection_attributes = nil
+
+      lambda { record.save! }.should_not raise_error
+      record.collection.should == []
+    end
+
+    it "continues to create and associate new records" do
+      record.collection_attributes = [{name: 'foo'}, {name: 'bar'}]
+
+      lambda { record.save! }.should_not raise_error
+
+      names = record.collection.map(&:name)
+      names.should include('foo')
+      names.should include('bar')
+    end
+
+    it "continues to update assoicated records" do
+      record.collection << member
+      record.collection_attributes = [{id: member.id, name: 'Foozle Cumberbunch'}]
+
+      lambda { record.save! }.should_not raise_error
+      record.collection.size.should == 1
+      record.collection.first.name.should == 'Foozle Cumberbunch'
+    end
+
+    # this also tests cyclic autosave problem that AutosaveAssociataionFix resolves
+    it "associates existing records" do
+      record.collection_attributes = [{id: member.id}]
+
+      lambda { record.save! }.should_not raise_error
+      record.collection.size.should == 1
+      record.collection.first.id.should == member.id
+    end
+
+    # this also tests cyclic autosave problem that AutosaveAssociataionFix resolves
+    it "keeps association for existing records that are already assoicated" do
+      record.collection << member
+      record.collection_attributes = [{id: member.id}]
+
+      lambda { record.save! }.should_not raise_error
+      record.collection.size.should == 1
+      record.collection.first.id.should == member.id
+    end
+
+    it "updates records that were just associated" do
+      record.collection_attributes = [{id: member.id, name: 'Foozle Cumberbunch'}]
+
+      lambda { record.save! }.should_not raise_error
+      record.collection.size.should == 1
+      record.collection.first.name.should == 'Foozle Cumberbunch'
+    end
+
+    it "ignores foreign key updates" do
+      different_foreign_key = record.id + 1
+      record.collection_attributes = [{id: member.id, name: 'Foozle Cumberbunch', nested_attribute_test_id: different_foreign_key}]
+
+      lambda { record.save! }.should_not raise_error
+
+      record.collection.size.should == 1
+      record.collection.first.nested_attribute_test_id.should == record.id
+    end
+
+    # this also tests cyclic autosave problem that AutosaveAssociataionFix resolves
+    it "updates previsoulsy associated records" do
+      record.collection << member
+
+      lambda { record.update!(collection_attributes: [{id: member.id, name: 'Foozle Cumberbunch'}]) }.should_not raise_error
+
+      record.collection.size.should == 1
+      record.collection.first.name.should == 'Foozle Cumberbunch'
+    end
+  end
+
+  describe 'has_one' do
+    let(:record) { create(:single_nested_attribute_test) }
+    let(:member) { create(:assoc_nested_attribute_test) }
+
+    it "ignores nil values" do
+      record.single = nil
+
+      lambda { record.save! }.should_not raise_error
+      record.single.should be_nil
+    end
+
+    it "continues to create and associate new records" do
+      record.single_attributes = {name: 'wibble'}
+
+      lambda { record.save! }.should_not raise_error
+
+      record.single.name.should == 'wibble'
+    end
+  end
+end

data/spec/rails/extensions/render_json_meta_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+class AssociatedRenderJsonMetaTest < ActiveRecord::Base
+end
+
+class RenderJsonMetaTest < ActiveRecord::Base
+  has_many :children, class_name: 'AssociatedRenderJsonMetaTest'
+
+  accepts_nested_attributes_for :children
+end
+
+# this implicitly tests read_only attributes
+class RenderJsonMetaTestSerializer < ActiveModel::Serializer
+  read_only :name, :valid?
+
+  def valid?; true; end
+end
+
+class RenderJsonMetaTestController < ActionController::Base
+  # The read_only values will be activated based on Serializer
+  def index
+    render json: RenderJsonMetaTest.all
+  end
+
+  def show
+    render json: RenderJsonMetaTest.find(params[:id])
+  end
+
+  # AssociatonRelation will activate where_values
+  def associated
+    render json: RenderJsonMetaTest.find(params[:id]).children.where(name: params[:name])
+  end
+
+  def child
+    render json: AssociatedRenderJsonMetaTest.find(params[:id])
+  end
+end
+
+describe RenderJsonMeta, type: [:controller, :routing] do
+
+  def self.controller_class
+    RenderJsonMetaTestController
+  end
+
+  migrate do
+    create_table :render_json_meta_tests do |t|
+      t.string  :name
+    end
+
+    create_table :associated_render_json_meta_tests do |t|
+      t.string  :name
+      t.integer :render_json_meta_test_id
+    end
+  end
+
+  before do
+    @routes.draw do
+      resources :render_json_meta_test do
+        get 'associated', on: :member
+        get 'child',      on: :member
+      end
+    end
+  end
+
+  before :all do
+    FactoryGirl.define do
+      factory :render_json_meta_test do
+        name { Faker::Name.name }
+      end
+
+      factory :associated_render_json_meta_test do
+        name { Faker::Name.name }
+      end
+    end
+  end
+
+  after :all do
+    Rails.application.reload_routes!
+  end
+
+  let!(:record1)    { create(:render_json_meta_test) }
+  let!(:record2)    { create(:render_json_meta_test) }
+  let!(:associated) { create(:associated_render_json_meta_test, render_json_meta_test_id: record1.id) }
+
+  describe "read_only" do
+    it 'renders on record' do
+      get :show, id: record1.id
+
+      # tests for no '?' on valid in both the attribute and read_only names
+      json = JSON.parse(response.body)
+      json['render_json_meta_test'].keys.should include('valid')
+      json['meta']['render_json_meta_test'].should include({'read_only' => ['name', 'valid']})
+    end
+
+    it 'renders on collection' do
+      get :index
+
+      json = JSON.parse(response.body)
+      json['meta']['render_json_meta_test'].should include({'read_only' => ['name', 'valid'] })
+    end
+
+    it 'renders no metadata' do
+      get :child, id: associated.id
+
+      json = JSON.parse(response.body)
+      json.keys.should_not include('meta')
+    end
+  end
+
+  describe "nested_resources" do
+    it 'renders on record' do
+      get :show, id: record1.id
+
+      # tests for no '?' on valid in both the attribute and read_only names
+      json = JSON.parse(response.body)
+      json['meta']['render_json_meta_test'].should include({'nested_resources' => ['children']})
+    end
+
+    it 'renders on collection' do
+      get :index
+
+      json = JSON.parse(response.body)
+      json['meta']['render_json_meta_test'].should include({'nested_resources' => ['children']})
+    end
+
+    it 'renders no metadata' do
+      get :child, id: associated.id
+
+      json = JSON.parse(response.body)
+      json.keys.should_not include('meta')
+    end
+  end
+
+  it 'renders where_values' do
+    get :associated, id: record1.id, name: associated.name
+
+    json = JSON.parse(response.body)
+    json['meta']['where_values'].should == {'render_json_meta_test_id' => associated.render_json_meta_test_id , 'name' => associated.name }
+  end
+end