opium 1.0.0.beta

data/spec/opium/model/connectable_spec.rb

@@ -0,0 +1,218 @@
+require 'spec_helper.rb'
+
+describe Opium::Model::Connectable do
+  before do
+    stub_const( 'Model', Class.new do |klass|
+      include Opium::Model::Connectable
+      stub('model_name').and_return(ActiveModel::Name.new(klass, nil, 'Model'))
+    end )
+  end
+  
+  after do
+    Opium::Model::Criteria.models.clear
+  end
+    
+  subject { Model }
+  let( :response ) { double('Response').tap {|r| allow(r).to receive(:body) } }
+  
+  it { is_expected.to respond_to( :connection, :reset_connection! ) }
+  it { is_expected.to respond_to( :object_prefix, :no_object_prefix! ) }
+  it { is_expected.to respond_to( :as_resource, :resource_name ).with(1).argument }
+  it { is_expected.to respond_to( :http_get, :http_post, :http_delete ).with(1).argument }
+  it { is_expected.to respond_to( :http_put ).with(2).arguments }
+  it { is_expected.to respond_to( :requires_heightened_privileges!, :requires_heightened_privileges? ) }
+  
+  describe '.object_prefix' do
+    it { expect( subject.object_prefix ).to eq 'classes' }
+  end
+  
+  describe '.reset_connection!' do
+    it { expect { subject.reset_connection! }.to change( subject, :connection ) }
+  end
+  
+  describe '.no_object_prefix!' do
+    after do
+      Model.instance_variable_set :@object_prefix, nil
+    end
+    
+    it 'has an empty object_prefix' do
+      expect { subject.no_object_prefix! }.to change( subject, :object_prefix ).from( 'classes' ).to( '' )
+    end
+  end
+  
+  describe '.as_resource' do
+    it { expect { subject.as_resource }.to raise_exception(ArgumentError) }
+    it do
+      expect {|b| subject.as_resource( :masked, &b ) }.to yield_control
+    end
+    
+    it { expect { subject.as_resource( :masked ) {} }.to_not change( subject, :resource_name ) }
+    
+    it 'changes the .resource_name within a block' do
+      subject.as_resource( :masked ) do
+        expect( subject.resource_name ).to eq 'masked'
+      end
+    end
+  end
+  
+  describe '.resource_name' do
+    it 'is based off the class name' do
+      subject.resource_name.should == 'classes/Model'
+    end
+    
+    it 'is able to include a resource id' do
+      subject.resource_name('abc123').should == 'classes/Model/abc123'
+    end
+    
+    it 'demodulizes the model_name' do
+      namespaced_model = subject
+      namespaced_model.stub(:model_name).and_return(ActiveModel::Name.new(subject, nil, 'Namespace::Model'))
+      namespaced_model.should_receive(:resource_name).and_call_original
+      namespaced_model.model_name.name.should == 'Namespace::Model'
+      namespaced_model.resource_name.should == 'classes/Model'
+    end
+  end
+  
+  shared_examples_for 'a sent-headers response' do |method, *args|
+    let(:options) { args.last.is_a?(Hash) ? args.pop : {} }
+    let(:params) { args.push options.merge( sent_headers: true ) }
+    let(:request) { subject.send( :"http_#{method}", *params ) }
+    
+    it { expect { request }.to_not raise_exception }
+    
+    it { expect( request ).to be_a(Hash) }
+    
+    if [:put, :post].include? method
+      context 'when including a JSON encoded body' do
+        it { expect( request ).to have_key 'Content-Type' }
+        it { expect( request['Content-Type'] ).to eq 'application/json' }
+      end
+    end
+    
+    context 'when not .requires_heightened_prvileges?' do
+      before { subject.instance_variable_set :@requires_heightened_privileges, nil }
+      
+      it { expect( subject.requires_heightened_privileges? ).to eq false }
+      
+      it { expect( request.keys ).to include( 'X-Parse-Application-Id', 'X-Parse-Rest-Api-Key' ) }
+      it { expect( request.keys ).to_not include( 'X-Parse-Master-Key', 'X-Parse-Session-Token' ) }
+    end
+    
+    unless method == :get
+      context 'when .requires_heightened_privileges?' do
+        subject do
+          Model.requires_heightened_privileges!
+          Model.send( :"http_#{method}", *params )
+        end
+        
+        after { Model.instance_variable_set :@requires_heightened_privileges, nil }
+                
+        it { expect( subject.keys ).to include( 'X-Parse-Application-Id', 'X-Parse-Master-Key' ) }
+        it { expect( subject.keys ).to_not include( 'X-Parse-Rest-Api-Key', 'X-Parse-Session-Token' ) }
+      end
+    end
+  end
+  
+  describe '.http_get' do
+    before do
+      stub_request( :get, %r{https://api.parse.com/1/classes/Model(\?.+)?} ).
+        to_return( status: 200, body: { objectId: 'abc123' }.to_json, headers: { 'Content-Type' => 'application/json' } )
+    end
+    
+    it 'executes a :get on :connection' do
+      subject.connection.should_receive(:get) { response }.with( 'classes/Model' )
+      subject.http_get
+    end
+    
+    it 'uses a resource id if passed an :id option' do
+      subject.connection.should_receive(:get) { response }.with( 'classes/Model/abcd1234' )
+      subject.http_get id: 'abcd1234'
+    end
+    
+    it 'returns a raw response if passed :raw_response' do
+      subject.http_get( raw_response: true ).should be_a( Faraday::Response )
+    end
+    
+    it 'sets params for everything within the :query hash' do
+      response = subject.http_get query: { keys: 'title,price', order: '-title', limit: 5 }, raw_response: true
+      request_params = response.env.url.query.split('&').map {|p| p.split('=')}
+      request_params.should =~ { 'keys' => 'title%2Cprice', 'order' => '-title', 'limit' => '5' }
+    end
+    
+    it 'special cases a :query key of "where", making it json encoded' do
+      criteria = { price: { '$lte' => 5 } }
+      response = subject.http_get query: { where: criteria }, raw_response: true
+      query = URI.decode response.env.url.query
+      query.should == "where=#{criteria.to_json}"
+    end
+    
+    it_behaves_like 'a sent-headers response', :get
+  end
+  
+  describe '.http_post' do
+    it 'executes a :post on :connection' do
+      subject.connection.should_receive(:post) { response }
+      subject.http_post( {} )
+    end
+    
+    it_behaves_like 'a sent-headers response', :post, {}, {}
+  end
+  
+  describe '.http_put' do
+    it 'executes a :put on :connection' do
+      subject.connection.should_receive(:put) { response }
+      subject.http_put( 'abcd1234', {} )
+    end
+    
+    it_behaves_like 'a sent-headers response', :put, 'abcd1234', {}, {}
+  end
+  
+  describe '.http_delete' do
+    it 'executes a :delete on :connection' do
+      subject.connection.should_receive(:delete) { response }
+      subject.http_delete( 'abcd1234' )
+    end
+    
+    it_behaves_like 'a sent-headers response', :delete, 'abcd1234'
+  end
+  
+  describe '.requires_heightened_privileges!' do
+    shared_examples_for 'it has heightened privileges on' do |method, *args|
+      before do
+        resource = args.first.is_a?(Hash) ? '' : "/#{args.first}"
+        to_send = method == :delete ? {} : {body: "{}"}
+        headers = method == :delete ? {} : {content_type: 'application/json'}
+        stub_request(method, "https://api.parse.com/1/classes/Model#{resource}").
+          with(
+            to_send.merge(
+              headers: headers.merge( x_parse_application_id: 'PARSE_APP_ID', x_parse_master_key: 'PARSE_MASTER_KEY' )
+            )
+          ).to_return(:status => 200, :body => "{}", :headers => {content_type: 'application/json'})
+      end
+      
+      it "causes :http_#{method} to add a master-key header" do
+        subject.requires_heightened_privileges!
+        expect { subject.send( :"http_#{method}", *args ) }.to_not raise_exception
+      end
+    end
+    
+    after { subject.instance_variable_set :@requires_heightened_privileges, nil }
+    
+    it { subject.requires_heightened_privileges!.should == true }
+    
+    it_behaves_like 'it has heightened privileges on', :post, {}
+    it_behaves_like 'it has heightened privileges on', :put, 'abcd1234', {}
+    it_behaves_like 'it has heightened privileges on', :delete, 'abcd1234'
+  end
+  
+  describe '.requires_heightened_privileges?' do
+    after { subject.instance_variable_set :@requires_heightened_privileges, nil }
+    
+    it { subject.requires_heightened_privileges?.should == false }
+    
+    it 'is true if privileges have been raised' do
+      subject.requires_heightened_privileges!
+      subject.requires_heightened_privileges?.should == true
+    end
+  end
+end

data/spec/opium/model/criteria_spec.rb

@@ -0,0 +1,285 @@
+require 'spec_helper.rb'
+
+describe Opium::Model::Criteria do
+  before do
+    stub_const( 'Game', Class.new do |klass|
+      include Opium::Model
+      field :title, type: String
+      field :price, type: Float
+      
+      stub('model_name').and_return(ActiveModel::Name.new(klass, nil, 'Game'))
+    end )
+    
+    stub_request( :get, 'https://api.parse.com/1/classes/Game?count=1' ).with( body: {} ).
+      to_return( status: 200, headers: { 'Content-Type' => 'application/json' }, body: {
+        count: 10,
+        results: [
+          { objectId: 'abcd1234', createdAt: Time.now - 50000, title: 'Skyrim', price: 45.99 },
+          { objectId: 'efgh5678', createdAt: Time.now - 10000, title: 'Terraria', price: 15.99 }
+        ]
+      }.to_json )
+  end
+  
+  after do
+    Opium::Model::Criteria.models.clear
+  end
+  
+  subject { Opium::Model::Criteria.new( 'Object' ) }
+  
+  it { is_expected.to be_a( Opium::Model::Queryable::ClassMethods ) }
+  it { is_expected.to be_an( Enumerable ) }
+  it { is_expected.to respond_to( :chain ) }
+  it { is_expected.to respond_to( :constraints, :variables ) }
+  it { is_expected.to respond_to( :update_constraint, :update_variable ).with(2).arguments }
+  it { is_expected.to respond_to( :constraints?, :variables? ) }
+  it { is_expected.to respond_to( :model, :model_name ) }
+  it { is_expected.to respond_to( :empty? ) }
+  it { is_expected.to respond_to( :to_parse ) }
+  it { is_expected.to respond_to( :each ) }
+  it { is_expected.to respond_to( :to_a ) }
+  it { is_expected.to respond_to( :count, :total_count ) }
+  
+  describe '#chain' do
+    it 'returns a copy of the object' do
+      result = subject.chain
+      result.should be_a( Opium::Model::Criteria )
+      result.should == subject
+      result.should_not equal( subject )
+    end
+  end
+  
+  describe '#update_constraint' do    
+    it 'chains the criteria and alter the specified constraint on the copy' do
+      result = subject.update_constraint( :order, ['title', 1] )
+      result.should be_a( Opium::Model::Criteria )
+      result.should_not equal( subject )
+      result.should_not == subject
+      result.constraints.should have_key( :order )
+      result.constraints[:order].should == ['title', 1]
+    end
+    
+    it 'merges hash-valued constraints' do
+      subject.constraints['where'] = { score: { '$lte' => 321 } }
+      result = subject.update_constraint( 'where', price: { '$gte' => 123 } )
+      result.constraints['where'].should =~ { 'score' => { '$lte' => 321 }, 'price' => { '$gte' => 123 } }
+    end
+    
+    it 'deep merges hash-valued constraints' do
+      subject.constraints['where'] = { score: { '$lte' => 321 } }
+      result = subject.update_constraint( 'where', score: { '$gte' => 123 } )
+      result.constraints['where'].should =~ { 'score' => { '$lte' => 321, '$gte' => 123 } }
+    end
+  end
+  
+  describe '#update_variable' do
+    it 'chains the criteria and alter the specified instance variable on the copy' do
+      result = subject.update_variable( :cache, true )
+      result.should be_an( Opium::Model::Criteria )
+      result.should_not equal( subject )
+      result.should_not == subject
+      result.constraints.should_not have_key( :cache )
+      result.variables.should have_key( :cache )
+      result.variables[:cache].should == true
+    end
+  end
+  
+  describe '#==' do
+    let( :first ) { Opium::Model::Criteria.new( 'Object' ).update_constraint( :order, ['title', 1] ) }
+    let( :second ) { Opium::Model::Criteria.new( 'Object' ).update_constraint( :order, ['title', 1] ) }
+    
+    it 'should not affect :equal?' do
+      first.should_not equal( second )
+    end
+    
+    it 'is based on the criteria constraints' do
+      first.should == second
+    end
+    
+    it 'is based on the criteria variables' do
+      third = first.update_variable( :cache, true )
+      second.should_not == third
+    end
+  end
+  
+  describe '#criteria' do
+    subject { Opium::Model::Criteria.new( 'Object' ).update_constraint( :order, ['title', 1] ) }
+    
+    it 'is == to self' do
+      subject.criteria.should == subject
+    end
+    
+    it 'is not a duplicate of self' do
+      subject.criteria.should equal( subject )
+    end
+  end
+  
+  describe '#model' do
+    subject { Opium::Model::Criteria.new( 'Game' ) }
+    
+    it 'is the constantized version of :model_name' do
+      subject.model_name.should == 'Game'
+      subject.model.should == Game
+    end
+  end
+  
+  describe '#empty?' do
+    before do
+      stub_request(:get, "https://api.parse.com/1/classes/Game?count=1&where=%7B%22price%22:%7B%22$gte%22:9000.0%7D%7D").
+        to_return(
+          status: 200, 
+          body: {
+            count: 0,
+            results: []
+          }.to_json, 
+          headers: { content_type: 'application/json' }
+        )
+    end
+    
+    subject { Game.criteria }
+    
+    it { expect { subject.empty? }.to_not raise_exception }
+    it do
+      expect( subject ).to receive(:count).once.and_call_original
+      subject.empty?
+    end
+    
+    it 'returns true if count is 0' do
+      subject.gte( price: 9000.0 ).empty?.should == true
+    end
+    
+    it 'returns false if count is not 0' do
+      subject.criteria.empty? == false
+    end
+  end
+  
+  describe '#constraints?' do
+    it 'returns true if count is not the only constraint' do
+      Game.limit( 10 ).constraints?.should == true
+    end
+    
+    it 'returns false if count is the only constraint' do
+      Game.criteria.constraints?.should == false
+    end
+  end
+  
+  describe '#each' do
+    subject { Game.criteria }
+    
+    context 'without a block' do
+      it 'returns an Enumerator' do
+        subject.each.should be_a( Enumerator )
+      end
+    end
+    
+    context 'with a block' do
+      it "calls its :model's :http_get" do
+        subject.model.should receive(:http_get).with(query: subject.constraints)
+        subject.each {|model| }
+      end
+      
+      it 'yields to its block any results it finds' do
+        expect {|b| subject.each &b }.to yield_control.twice
+      end
+      
+      it 'yields to its block Opium::Model objects (Game in context)' do
+        expect {|b| subject.each &b }.to yield_successive_args(Opium::Model, Opium::Model)
+        expect {|b| subject.each &b }.to yield_successive_args(Game, Game)
+      end
+      
+      it "calls its :model's :http_get when counting" do
+        subject.model.should receive(:http_get).with(query: subject.constraints).twice
+        subject.each {|model| }
+        subject.each.count
+      end
+    end
+    
+    context 'when #cached?' do
+      subject { Game.criteria.cache }
+      
+      it 'calls its :model\'s :http_get only once' do
+        subject.model.should receive(:http_get).with(query: subject.constraints).once
+        subject.each {|model| }
+        subject.each {|model| }
+      end
+      
+      it 'yields to its block any results it finds' do
+        expect {|b| subject.each &b }.to yield_control.twice
+        expect {|b| subject.each &b }.to yield_control.twice
+      end
+      
+      it 'yields to its block Opium::Model objects (Game in context)' do
+        expect {|b| subject.each &b }.to yield_successive_args(Opium::Model, Opium::Model)
+        expect {|b| subject.each &b }.to yield_successive_args(Game, Game)
+      end
+      
+      it "does not call its :model's :http_get when counting" do
+        subject.model.should receive(:http_get).with(query: subject.constraints).once
+        subject.each {|model| }
+        subject.each.count
+      end
+    end
+  end
+  
+  describe '#uncache' do
+    subject { Game.criteria.cache }
+    
+    it 'causes #each to call its :model\'s :http_get twice' do
+      subject.model.should receive(:http_get).with(query: subject.constraints).twice
+      subject.each {|model| }
+      subject.uncache.each {|model| }
+    end
+    
+    it 'deletes its @cache' do
+      subject.each {|model| }
+      subject.uncache.instance_variable_get(:@cache).should be_nil
+    end
+  end
+  
+  describe '#count' do
+    subject { Game.criteria }
+    
+    it { expect { subject.count }.to_not raise_exception }
+    it do
+      expect( subject ).to receive(:each).and_call_original
+      subject.count
+    end
+    
+    it 'equals the number of items from #each' do
+      expect( subject.count ).to be == 2
+    end
+  end
+  
+  describe '#total_count' do
+    subject { Game.criteria }
+    
+    it { expect { subject.total_count }.to_not raise_exception }
+    it do
+      expect( subject ).to receive(:each).and_call_original
+      subject.total_count
+    end
+    
+    it "equals the 'count' result returned from parse" do
+      expect( subject.total_count ).to be == 10
+    end
+  end
+    
+  describe '#to_parse' do
+    subject { Game.criteria }
+    
+    it { expect( subject.to_parse ).to be_a( Hash ) }
+    
+    it 'has a "query" key, if a "where" constraint exists, containing a "where" and a "className"' do
+      Game.between( price: 5..10 ).to_parse.tap do |criteria|
+        criteria.should have_key( 'query' )
+        criteria['query'].should =~ { 'where' => { 'price' => { '$gte' => 5, '$lte' => 10 } }, 'className' => 'Game' }
+      end
+    end
+    
+    it 'should have a "key" key, if a "keys" constraint exists' do
+      Game.keys( :price ).to_parse.tap do |criteria|
+        criteria.should have_key( 'key' )
+        criteria['key'].should == 'price'
+      end
+    end
+  end
+end

data/spec/opium/model/dirty_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Opium::Model::Dirty do
+  let( :model ) { Class.new { def initialize(a = {}); end; def save(o = {}); end; include Opium::Model::Dirty; } }
+  
+  describe 'instance' do
+    subject { model.new }
+    
+    it { should respond_to( :changed?, :changed, :changed_attributes ) }
+  end
+  
+  describe 'when included in a model' do
+    before do
+      stub_const( 'Game', Class.new do
+        include Opium::Model
+        field :title, type: String
+      end )
+      stub_request(:post, "https://api.parse.com/1/classes/Game").with(
+        body: "{\"title\":\"Skyrim\"}",
+        headers: {'Content-Type'=>'application/json'}
+      ).to_return(
+        body: { objectId: 'abcd1234', createdAt: Time.now.to_s }.to_json, 
+        status: 200, 
+        headers: { 'Content-Type' => 'application/json', Location: 'https://api.parse.com/1/classes/Game/abcd1234' } 
+      )
+    end
+    
+    subject { Game.new( title: 'Skyrim' ) }
+    
+    it 'when instantiated, should not be changed' do
+      subject.should_not be_changed
+    end
+    
+    it 'when saved, should receive #changes_applied' do
+      subject.should receive(:changes_applied)
+      subject.save
+    end    
+  end
+end

data/spec/opium/model/fieldable_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe Opium::Model::Fieldable do
+  describe "in a model without explicit fields" do
+    let( :model ) { Class.new { include Opium::Model } }
+    
+    it { model.should respond_to( :fields ).with(0).arguments }
+    it "should have #fields [:id, :created_at, :updated_at]" do
+      model.fields.should be_a_kind_of( Hash )
+      model.fields.should_not be_empty
+      model.fields.keys.should =~ %w[id created_at updated_at]
+      model.fields.values.each do |f|
+        f.should be_a_kind_of( Opium::Model::Field )
+        f.should be_readonly
+      end
+    end
+  end
+  
+  describe "in a model with fields" do
+    let( :model ) do
+      Class.new do
+        include Opium::Model
+        field :name, type: String, default: "default"
+        field :price, type: Float, default: -> { 5.0 * 2 }
+        field :no_cast
+        field :cannot_be_directly_changed, readonly: true
+      end
+    end
+  
+    it { model.should respond_to( :field ).with(2).arguments }
+    it { model.should respond_to( :fields ).with(0).arguments }
+    it { model.should respond_to( :ruby_canonical_field_names ) }
+    it { model.should respond_to( :parse_canonical_field_names ) }
+        
+    it "should have #fields for every #field" do
+      model.fields.should be_a_kind_of( Hash )
+      model.fields.should_not be_empty
+      model.fields.keys.should =~ %w[name price no_cast cannot_be_directly_changed id created_at updated_at]
+      model.fields.values.each do |f|
+        f.should_not be_nil
+        f.should be_a_kind_of( Opium::Model::Field )
+      end 
+    end
+    
+    it "each #fields should have a #name, #as, #type, #default, #readonly, #readonly?" do
+      model.fields.values.each do |f|
+        f.should respond_to(:name, :as, :type, :default, :readonly, :readonly?)
+      end
+    end
+    
+    it "each #fields should have the type they were defined with" do
+      expected = {name: String, price: Float, no_cast: Object, cannot_be_directly_changed: Object, id: String, created_at: DateTime, updated_at: DateTime}
+      model.fields.values.each do |f|
+        f.type.should == expected[ f.name.to_sym ]
+      end
+    end
+    
+    it "each #fields should have the default they were defined with" do
+      expected = {name: "default", price: 10.0, no_cast: nil}
+      model.fields.values.each do |f|
+        f.default.should == expected[ f.name.to_sym ]
+      end
+    end
+    
+    it "each #fields should convert ruby names to parse names" do
+      expected = {name: "name", price: "price", no_cast: "noCast", cannot_be_directly_changed: "cannotBeDirectlyChanged", id: "objectId", created_at: "createdAt", updated_at: "updatedAt"}
+      model.fields.values.each do |f|
+        f.name_to_parse.should == expected[ f.name.to_sym ]
+      end
+    end
+        
+    it "should return the canonical ruby form of a given field name" do
+      expected = {name: 'name', price: 'price', noCast: 'no_cast', cannotBeDirectlyChanged: 'cannot_be_directly_changed', objectId: 'id', createdAt: 'created_at', updatedAt: 'updated_at'}
+      expected.each do |field_alias, expected_field_name|
+        model.ruby_canonical_field_names[field_alias].should == expected_field_name
+      end
+    end
+    
+    it "should return the canonical parse form of a given field name" do
+      expected = {name: 'name', price: 'price', no_cast: 'noCast', cannot_be_directly_changed: 'cannotBeDirectlyChanged', id: 'objectId', created_at: 'createdAt', updated_at: 'updatedAt'}
+      expected.each do |field_alias, expected_field_name|
+        model.parse_canonical_field_names[field_alias].should == expected_field_name
+      end
+    end
+    
+    it { model.should respond_to( :default_attributes ) }
+    
+    it "default_attributes should return its #fields default" do
+      expected = {"name" => "default", "price" => 10.0, "no_cast" => nil, "cannot_be_directly_changed" => nil, "id" => nil, "created_at" => nil, "updated_at" => nil}
+      model.default_attributes.should == expected
+    end
+  
+    describe "instance" do
+      subject { model.new }
+      
+      it "should not have setters for readonly fields" do
+        should_not respond_to( :cannot_be_directly_changed= ) 
+      end
+      
+      {name: "42", price: 42.0}.each do |field_name, expected_value|
+        it "should have a getter and setter for its fields" do
+          should respond_to( field_name ).with(0).arguments
+          should respond_to( :"#{field_name}=" ).with(1).argument
+        end
+    
+        it "should have a dirty tracking method for its fields" do
+          should respond_to( :"#{field_name}_will_change!" )
+        end
+    
+        it "should receive a dirty tracking update when the setter is called with a new value" do
+          subject.should_receive :"#{field_name}_will_change!"
+          subject.send(:"#{field_name}=", "changed!")
+        end
+    
+        it "should not receive a dirty tracking update when the setter is called with the current value" do
+          subject.send(:"#{field_name}=", "current")
+          subject.should_not_receive :"#{field_name}_will_change!"
+          subject.send(:"#{field_name}=", "current")
+        end
+        
+        it "should call the :to_ruby conversion method on the field type on setting" do
+          model.fields[field_name].type.should_receive(:to_ruby).at_least(:once)
+          subject.send(:"#{field_name}=", "42")
+        end
+        
+        it "should convert the value passed to its setter to the field's type" do
+          subject.send(:"#{field_name}=", "42")
+          subject.send(:"#{field_name}").should == expected_value
+        end
+      end
+    end
+  end
+end