opium 1.1.8 → 1.2.0

data/lib/opium/version.rb

@@ -1,3 +1,3 @@
 module Opium
-  VERSION = "1.1.8"
+  VERSION = "1.2.0"
 end

data/spec/opium/model/attributable_spec.rb

@@ -1,15 +1,6 @@
 require 'spec_helper'
 
 describe Opium::Model::Attributable do
-  let( :model ) { Class.new { include Opium::Model::Attributable } }
-  
-  context 'within an instance' do
-    subject { model.new }
-    
-    it { is_expected.to respond_to( :attributes, :attributes= ) }
-    it { is_expected.to respond_to( :attributes_to_parse ) }
-  end
-  
   context 'when included in a model' do
     before do
       stub_const( 'Book', Class.new do

data/spec/opium/model/batchable/batch_spec.rb

@@ -107,7 +107,10 @@ describe Opium::Model::Batchable::Batch do
     context 'when #queue is empty' do
       before { subject.queue.clear }
       
-      it { expect { subject.execute }.to raise_exception }
+      # it { expect { subject.execute }.to raise_exception }
+      
+      it { expect { subject.execute }.to_not raise_exception }
+      it { expect( subject.owner ).to_not receive(:http_post) }
     end
     
     context 'when #queue has more than MAX_BATCH_SIZE operations' do

data/spec/opium/model/batchable_spec.rb

@@ -2,4 +2,152 @@ require 'spec_helper'
 
 describe Opium::Model::Batchable do
   it { expect( described_class.constants ).to include( :Batch, :Operation ) }
+  
+  before do
+    stub_const( 'Game', Class.new do
+      include Opium::Model
+      field :title, type: String
+    end )
+    
+    stub_request(:get, "https://api.parse.com/1/classes/Game/abcd1234").
+      with(headers: {'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Rest-Api-Key'=>'PARSE_API_KEY'}).
+      to_return(:status => 200, :body => { objectId: 'abcd1234', title: 'Never Alone' }.to_json, :headers => {})
+      
+    stub_request(:get, "https://api.parse.com/1/classes/Game/efgh5678").
+      with(headers: {'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Rest-Api-Key'=>'PARSE_API_KEY'}).
+      to_return(:status => 200, :body => { objectId: 'efgh5678', title: 'Guacamelee' }.to_json, :headers => {})      
+  end
+  
+  describe '.batched?' do
+    let(:result) { Game.batched? }
+    
+    context 'when there is no batch job' do
+      it { expect( result ).to be_falsey }
+    end
+    
+    context 'when there is a batch job' do
+      before(:each) { Game.create_batch }
+      after(:each) { Game.delete_batch }
+      
+      it { expect( result ).to be_truthy }
+    end
+  end
+  
+  describe '.create_batch' do
+    after { Game.delete_batch }
+    let(:result) { Game.create_batch }
+    
+    context 'when there is no existing batch job' do
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a Opium::Model::Batchable::Batch }
+      it { expect( result.depth ).to be 0 }
+    end
+    
+    context 'when there is a current batch job' do
+      before { Game.create_batch }
+      after { Game.delete_batch }
+      
+      it { expect { result }.to_not raise_exception }
+      it( 'increments the depth' ) { expect( result.depth ).to eq 1 }
+    end
+  end
+  
+  describe '.delete_batch' do
+    let(:result) { Game.delete_batch }
+    
+    context 'when there is no existing batch job' do
+      it { expect { result }.to raise_exception }
+    end
+    
+    context 'when there is a current batch job' do
+      before { Game.create_batch }
+    
+      context 'with depth greater than 0' do
+        before { Game.create_batch }
+        after { Game.delete_batch }
+        
+        it { expect { result }.to_not raise_exception }
+        it { expect( result ).to be_a Opium::Model::Batchable::Batch }
+        it( 'decrements the depth' ) { expect( result.depth ).to eq 0 }
+      end
+      
+      context 'with depth of 0' do
+        it { expect { result }.to_not raise_exception }
+        it { expect( result ).to be_nil }
+      end
+    end
+  end
+  
+  describe '.current_batch_job' do
+    let(:result) { Game.current_batch_job }
+    
+    context 'when there is no batch job' do
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_nil }
+    end
+    
+    context 'when a batch job has been created' do
+      before { Game.create_batch }
+      after { Game.delete_batch }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a Opium::Model::Batchable::Batch }
+    end
+  end
+  
+  describe '.batch' do
+    let(:batch) { Game.batch( batch_options, &batch_block ) }
+    let(:batch_options) { { } }
+    let(:batch_block) { -> { } }
+    
+    context 'when given a block' do
+      it { expect { batch }.to_not raise_exception }
+      it { expect {|b| Game.batch( batch_options, &b ) }.to yield_control.at_least(1).times }
+      it 'is batched within the block' do
+        Game.batch( batch_options ) do
+          expect( Game ).to be_batched
+          
+          Game.batch( batch_options ) do
+            expect( Game ).to be_batched
+            expect( Game.current_batch_job.depth ).to eq 1
+          end
+          
+          expect( Game ).to be_batched
+          expect( Game.current_batch_job.depth ).to eq 0
+        end
+        expect( Game ).to_not be_batched
+      end
+    end
+    
+    context 'without a block' do
+      let(:batch_block) { }
+      
+      it { expect { batch }.to raise_exception }
+    end
+    
+    context 'with mode: :mixed' do
+      let(:batch_options) { { mode: :mixed } }
+      let(:batch_block) do
+        -> do
+          Game.find('abcd1234').save
+          Game.new( title: 'Skyrim' ).save
+          Game.find('efgh5678').destroy
+        end
+      end
+      
+      it { expect { batch }.to_not raise_exception }
+      
+    end
+    
+    context 'with mode: :ordered' do
+      let(:batch_options) { { mode: :ordered } }
+      let(:batch_block) do
+        -> do
+          Game.find('abcd1234').save
+          Game.new( title: 'Skyrim' ).save
+          Game.find('efgh5678').destroy
+        end
+      end
+    end
+  end
 end

data/spec/opium/model/fieldable_spec.rb

@@ -147,6 +147,22 @@ describe Opium::Model::Fieldable do
       expect( Model.default_attributes ).to include( 'symbolic_with_string_default' => :value, 'symbolic_with_symbol_default' => :value )
     end
     
+    describe '.has_field?' do
+      let(:result) { subject.has_field? field_name }
+      
+      context 'with a valid field_name' do
+        let(:field_name) { :symbolic_with_string_default }
+        
+        it { expect( result ).to be_truthy }
+      end
+      
+      context 'with an invalid field_name' do
+        let(:field_name) { :not_defined }
+        
+        it { expect( result ).to be_falsey }
+      end
+    end
+    
     describe '.field' do
       subject { Model.new }
       

data/spec/opium/model/reference_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Opium::Model::Reference do
+  before do
+    stub_const( 'Tree', Class.new do |klass| 
+      include Opium::Model
+      field :trees
+      
+      class << klass
+        stub(:model_name).and_return( ActiveModel::Name.new( self, nil, 'Tree' ) )
+      end
+    end )
+  end
+  
+  let(:child) { Tree.new id: 'c1234' }
+  let(:metadata) { Opium::Model::Relatable::Metadata.new( Tree, :belongs_to, :parent, class_name: 'Tree' ) }
+  
+  describe '.to_ruby' do
+    let(:result) { described_class.to_ruby( subject ) }
+    
+    context 'when given a hash' do
+      subject { { metadata: metadata, context: child } }
+      
+      it { expect( result ).to be_a described_class }
+      it { expect( result.metadata ).to eq metadata }
+      it { expect( result.context ).to eq child }
+      it { expect( result ).to be_a Delegator }
+    end
+    
+    context 'when given a Reference' do
+      subject { described_class.new( metadata, child ) }
+
+      it { expect( result ).to be_a described_class }
+      it { expect( result.metadata ).to eq metadata }
+      it { expect( result.context ).to eq child }
+      it { expect( result ).to be_a Delegator }
+    end
+  end
+  
+  describe '.to_parse' do
+  end
+  
+  describe '.__getobj__' do
+    subject { described_class.new( metadata, child ) }
+    let(:result) { subject.__getobj__ }
+    
+    context 'when parse returns no results' do
+      before do
+        stub_request(:get, "https://api.parse.com/1/classes/Tree?count=1&where=%7B%22trees%22:%7B%22__type%22:%22Pointer%22,%22className%22:%22Tree%22,%22objectId%22:%22c1234%22%7D%7D").
+          with(headers: {'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Rest-Api-Key'=>'PARSE_API_KEY'}).
+          to_return(status: 200, body: { results: [], count: 0 }.to_json, headers: { content_type: 'application/json' })
+      end
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_nil }
+    end
+    
+    context 'when parse returns a result' do
+      before do
+        stub_request(:get, "https://api.parse.com/1/classes/Tree?count=1&where=%7B%22trees%22:%7B%22__type%22:%22Pointer%22,%22className%22:%22Tree%22,%22objectId%22:%22c1234%22%7D%7D").
+          with(headers: {'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Rest-Api-Key'=>'PARSE_API_KEY'}).
+          to_return(status: 200, body: { results: [
+            { objectId: 'abcd1234' }
+          ], count: 1 }.to_json, headers: { content_type: 'application/json' })
+        allow(Tree).to receive(:model_name).and_return( ActiveModel::Name.new( Tree, nil, 'Tree' ) )
+      end
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to_not be_nil }
+      it { expect( result ).to be_a Opium::Model }
+    end
+  end
+end

data/spec/opium/model/relatable/metadata_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Opium::Model::Relatable::Metadata do
+  before do
+    stub_const( 'Model', Class.new do |klass|
+      stub('model_name').and_return( ActiveModel::Name.new( klass, nil, 'Model' ) )
+    end )
+  end
+  
+  describe 'inverse_relation_name' do
+    let(:result) { subject.inverse_relation_name }
+    
+    context 'when created with an :inverse_of key' do
+      subject { described_class.new( Model, :belongs_to, :parent, class_name: 'Model', inverse_of: :children ) }
+      
+      it( 'uses the :inverse_of value' ) { expect( result ).to eq 'children' }
+    end
+    
+    context 'when inferred from a :has_many context' do
+      subject { described_class.new( Model, :has_many, :articles ) }
+      
+      it( 'uses the singular of its model name' ) { expect( result ).to eq 'model' }
+    end
+    
+    context 'when inferred from a :belongs_to context' do
+      subject { described_class.new( Model, :belongs_to, :article ) }
+      
+      it( 'uses the plural of its model name' ) { expect( result ).to eq 'models' }
+    end
+  end
+end

data/spec/opium/model/relatable_spec.rb

@@ -0,0 +1,220 @@
+require 'spec_helper'
+
+describe Opium::Model::Relatable do
+  before do
+    stub_const( 'Game', Class.new do |klass|
+      include Opium::Model
+      stub(:model_name).and_return( ActiveModel::Name.new( klass, nil, 'Game' ) )
+      
+      field :title, type: String
+      has_and_belongs_to_many :players
+    end )
+    
+    stub_const( 'Player', Class.new do |klass|
+      include Opium::Model
+      stub(:model_name).and_return( ActiveModel::Name.new( klass, nil, 'Player' ) )
+      
+      field :tag, type: String
+      has_and_belongs_to_many :games 
+    end )
+    
+    stub_const( 'Article', Class.new do |klass|
+      include Opium::Model
+      
+      instance_eval do
+        def model_name
+          ActiveModel::Name.new( self, nil, 'Article' )
+        end
+      end
+      
+      field :title, type: String
+      has_many :comments
+      belongs_to :author, class_name: 'User'
+    end )
+    
+    stub_const( 'Comment', Class.new do |klass|
+      include Opium::Model
+      
+      instance_eval do
+        def model_name
+          ActiveModel::Name.new( self, nil, 'Comment' )
+        end
+      end
+      
+      field :body
+      belongs_to :article
+    end )
+    
+    stub_const( 'User', Class.new(Opium::User) do |klass|
+      stub(:model_name).and_return( ActiveModel::Name.new( klass, nil, 'User' ) )
+      
+      has_many :articles
+      has_one :profile
+    end ) 
+    
+    stub_const( 'Profile', Class.new do |klass|
+      include Opium::Model
+      stub(:model_name).and_return( ActiveModel::Name.new( klass, nil, 'Profile' ) )
+      
+      field :first_name, type: String
+      belongs_to :user
+    end )
+    
+    stub_const( 'Event', Class.new do |klass|
+      include Opium::Model
+      stub(:model_name).and_return( ActiveModel::Name.new( klass, nil, 'Event' ) )
+    
+      field :title, type: String
+    end )
+    
+    stub_request(:get, "https://api.parse.com/1/classes/Comment?count=1&where=%7B%22$relatedTo%22:%7B%22object%22:%7B%22__type%22:%22Pointer%22,%22className%22:%22Article%22,%22objectId%22:%22abcd1234%22%7D,%22key%22:%22comments%22%7D%7D").
+      with(headers: {'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Rest-Api-Key'=>'PARSE_API_KEY'}).
+      to_return(status: 200, body: {
+        count: 2,
+        results: [
+          { objectId: 'c1234', body: 'A Moose once bit my sister...' },
+          { objectId: 'c5678', body: 'No realli! She was Karving her initials on the moose' }
+        ]
+      }.to_json, headers: { content_type: 'application/json' })
+      
+    stub_request(:get, "https://api.parse.com/1/classes/Comment?count=1&where=%7B%22$relatedTo%22:%7B%22object%22:%7B%22__type%22:%22Pointer%22,%22className%22:%22Article%22,%22objectId%22:%22a1234%22%7D,%22key%22:%22comments%22%7D%7D").
+      with(headers: {'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Rest-Api-Key'=>'PARSE_API_KEY'}).
+      to_return(status: 200, body: {
+        count: 1,
+        results: [
+          { objectId: 'c2345', body: 'Seems plausible.' }
+        ]
+      }.to_json, headers: { content_type: 'application/json' })
+      
+    stub_request(:get, "https://api.parse.com/1/classes/Article?count=1&where=%7B%22comments%22:%7B%22__type%22:%22Pointer%22,%22className%22:%22Comment%22,%22objectId%22:%22c1234%22%7D%7D").
+      with(headers: {'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Rest-Api-Key'=>'PARSE_API_KEY'}).
+      to_return(status: 200, body: {
+        count: 1,
+        results: [
+          { objectId: 'abcd1234', title: 'Funny Subtitles' }
+        ]
+      }.to_json, headers: { content_type: 'application/json' })
+      
+    stub_request(:post, "https://api.parse.com/1/classes/Article").
+      with(body: "{\"title\":\"A new approach to Sandboxes\"}",
+        headers: {'Content-Type'=>'application/json', 'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Rest-Api-Key'=>'PARSE_API_KEY'}).
+      to_return(status: 200, body: { objectId: 'a1234', createdAt: Time.now.utc }.to_json, headers: { content_type: 'appliction/json' })
+      
+    stub_request(:post, "https://api.parse.com/1/classes/Comment").
+      with(body: "{\"body\":\"Do. Not. Want.\"}",
+        headers: {'Content-Type'=>'application/json', 'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Rest-Api-Key'=>'PARSE_API_KEY'}).
+      to_return(status: 200, body: { objectId: 'c7896', createdAt: Time.now.utc }.to_json, headers: { content_type: 'application/json' })
+      
+    stub_request(:put, "https://api.parse.com/1/classes/Article/a1234").
+      with(body: "{\"comments\":{\"__op\":\"AddRelation\",\"objects\":[{\"__type\":\"Pointer\",\"className\":\"Comment\",\"objectId\":\"c7896\"}]}}",
+        headers: {'Content-Type'=>'application/json', 'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Rest-Api-Key'=>'PARSE_API_KEY'}).
+      to_return(status: 200, body: { updatedAt: Time.now.utc }.to_json, headers: { content_type: 'application/json' })
+  end
+  
+  describe '.relations' do
+    let(:result) { subject.relations }
+    
+    context 'within a model with multiple relations' do
+      subject { User }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a Hash }
+      it { expect( result.keys ).to include( 'articles', 'profile' ) }
+    end
+    
+    context 'within a model with no relations' do
+      subject { Event }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a Hash }
+      it { expect( result ).to be_empty }
+    end
+  end
+  
+  describe '.has_many' do
+    subject { Article }
+    let(:result) { subject.relations[relation_name] }
+    let(:relation_name) { :comments }
+    
+    it { expect( result ).to be_a Opium::Model::Relatable::Metadata }
+    
+    it { is_expected.to have_field :comments }
+    it { expect( subject.fields[:comments].type ).to eq Opium::Model::Relation }
+    it { expect( subject.fields[:comments].default ).to_not be_nil }
+    
+    context 'within a new model' do
+      subject { Article.new }
+      
+      it { expect( subject.comments ).to_not be_nil }
+      it { expect( subject.comments ).to be_a Opium::Model::Relation }
+      it('adds a constraint for the owner of the relation') { expect( subject.comments.constraints['where'] ).to include( '$relatedTo' => { 'object' => subject.to_parse, 'key' => 'comments' } ) }
+      it { expect( subject.comments ).to be_empty }
+      it { expect( subject.comments.owner ).to eq subject }
+    end
+    
+    context 'when a model has existing relations' do
+      subject { Article.new id: 'abcd1234' }
+      
+      it { expect( subject.comments ).to_not be_nil }
+      it { expect( subject.comments ).to be_a Opium::Model::Relation }
+      it('adds a constraint for the owner of the relation') { expect( subject.comments.constraints['where'] ).to include( '$relatedTo' => { 'object' => subject.to_parse, 'key' => 'comments' } ) }
+      it { expect( subject.comments ).to_not be_empty }
+      it { expect( subject.comments.owner ).to eq subject }
+    end
+  end
+  
+  describe '.has_one' do
+  end
+  
+  describe '.belongs_to' do
+    subject { Comment }
+    let(:result) { subject.relations[relation_name] }
+    let(:relation_name) { :article }
+    
+    it { expect( result ).to be_a Opium::Model::Relatable::Metadata }
+    
+    it { is_expected.to have_field :article }
+    it { expect( subject.fields[:article].type ).to eq Opium::Model::Reference }
+    it { expect( subject.fields[:article].default ).to be_a Hash }
+    
+    context 'within a new model' do
+      subject { Comment.new }
+      
+      it { expect( subject.article ).to_not be_nil }
+      it { expect( subject.article ).to be_a Opium::Model::Reference }
+      it { expect( subject.article.context ).to eq subject }
+      it { expect { subject.article.__getobj__ }.to_not raise_exception }
+      it { expect( subject.article.__getobj__ ).to be_nil }
+    end
+    
+    context 'within an existing model' do
+      subject { Comment.new id: 'c1234' }
+      
+      it { expect( subject.article ).to_not be_nil }
+      it { expect( subject.article ).to be_a Opium::Model::Reference }
+      it { expect( subject.article.context ).to eq subject }
+      it( 'loads the proper model id' ) { expect( subject.article.id ).to eq 'abcd1234' }
+      it( 'loads a properly typed model') { expect( subject.article.model_name ).to eq 'Article' }
+    end
+  end
+  
+  describe '.has_and_belongs_to_many' do
+  end
+  
+  describe '#save' do
+    let(:result) { subject.save }
+    
+    context 'within a model with a has_many relation' do
+      subject { Article.new title: 'A new approach to Sandboxes' }
+      before { subject.comments.build body: 'Do. Not. Want.' }
+      
+      it { result; expect( subject.errors ).to be_empty }
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_truthy }
+      it { result && is_expected.to( be_persisted ) }
+      it { result && expect( subject.comments ).to( be_a Opium::Model::Relation ) }
+      it { result && expect( subject.comments ).to( all( be_a( Opium::Model ) ) ) }
+      it { result && expect( subject.comments ).to( all( be_persisted ) ) }
+    end
+  end
+end