opium 1.0.0.beta

data/spec/opium/model/queryable_spec.rb

@@ -0,0 +1,338 @@
+require 'spec_helper.rb'
+
+describe Opium::Model::Queryable do
+  let( :model ) { Class.new { include Opium::Model::Queryable } }
+
+  describe 'the class' do
+    subject { model }
+    
+    it { should respond_to( :all, :all_in ).with(1).argument }
+    it { should respond_to( :and ).with(1).argument }
+    it { should respond_to( :between ).with(1).argument }
+    it { should respond_to( :exists ).with(1).argument }
+    it { should respond_to( :gt, :gte ).with(1).argument }
+    it { should respond_to( :lt, :lte ).with(1).argument }
+    it { should respond_to( :in, :any_in, :nin ).with(1).argument }
+    it { should respond_to( :ne ).with(1).argument }
+    it { should respond_to( :or ).with(1).argument }
+    it { should respond_to( :select, :dont_select ).with(1).argument }
+    it { should respond_to( :keys, :pluck ).with(1).argument }
+    it { should respond_to( :where ).with(1).argument }
+    it { should respond_to( :order ).with(1).argument }
+    it { should respond_to( :limit, :skip ).with(1).argument }
+    it { should respond_to( :cache, :uncache, :cached? ) }
+    it { should respond_to( :count, :total_count ) }
+  end
+  
+  describe 'within a model' do
+    before do
+      stub_const( 'Game', Class.new do
+        include Opium::Model
+        field :title, type: String
+        field :price, type: Float
+        
+        stub(:model_name).and_return( 'Game' )
+        
+        default_scope order( title: :asc )
+      end )
+    end
+    
+    after do
+      Opium::Model::Criteria.models.clear
+    end
+    
+    subject { Game }
+    
+    describe ':where' do
+      it 'should return a criteria' do
+        subject.where( price: { '$lte' => 5 } ).should be_a( Opium::Model::Criteria )
+      end
+      
+      it 'should set the "where" constraint to the provided value' do
+        subject.where( price: { '$lte' => 5 } ).tap do |criteria|
+          criteria.constraints.should have_key( 'where' )
+          criteria.constraints['where'].should =~ { 'price' => { '$lte' => 5 } }
+        end
+      end
+      
+      it 'should deep merge the "where" constraint on successive calls' do
+        subject.where( price: { '$lte' => 5 } ).where( price: { '$gte' => 1 } ).tap do |criteria|
+          criteria.constraints['where'].should =~ { 'price' => { '$lte' => 5, '$gte' => 1 } }
+        end
+      end
+      
+      it 'should ensure that specified fields exist on the model' do
+        expect { subject.where( does_not_exist: true ) }.to raise_exception
+      end
+      
+      it 'should map ruby names to parse names and ruby values to parse values' do
+        time = Time.now - 1000
+        subject.where( created_at: { '$gte' => time } ).tap do |criteria|
+          criteria.constraints['where'].should =~ { 'createdAt' => { '$gte' => time.to_parse } }
+        end
+      end
+    end
+        
+    shared_examples_for 'a chainable criteria clause' do |method|
+      describe ":#{method}" do
+        it 'should return a criteria' do
+          subject.send( method, price: 5, title: 'Skyrim' ).should be_a( Opium::Model::Criteria )
+        end
+      
+        it "should add a \"$#{method}\" clause to the where constraint for each member of the hash" do
+          subject.send( method, price: 5, title: 'Skyrim' ).tap do |criteria|
+            criteria.constraints.should have_key( 'where' )
+            criteria.constraints['where'].should =~ { 'price' => { "$#{method}" => 5 }, 'title' => { "$#{method}" => 'Skyrim' } }
+          end
+        end
+      end
+    end
+    
+    it_should_behave_like 'a chainable criteria clause', :gte
+    it_should_behave_like 'a chainable criteria clause', :lte
+    it_should_behave_like 'a chainable criteria clause', :gt
+    it_should_behave_like 'a chainable criteria clause', :lt
+    it_should_behave_like 'a chainable criteria clause', :ne
+    
+    shared_examples_for 'a chainable array-valued criteria clause' do |method|
+      describe ":#{method}" do
+        it 'should return a criteria' do
+          subject.send( method, price: [1, 2, 3, 4] ).should be_a( Opium::Model::Criteria )
+        end
+        
+        it "should add a \"$#{method}\" clause to the where constraint for each member of the hash, converting pair values to arrays" do
+          subject.send( method, price: 1..4, title: ['Skyrim', 'Oblivion'] ).tap do |criteria|
+            criteria.constraints.should have_key( 'where' )
+            criteria.constraints['where'].should =~ { 'price' => { "$#{method}" => [1, 2, 3, 4] }, 'title' => { "$#{method}" => ['Skyrim', 'Oblivion'] } }
+          end
+        end
+      end
+    end
+    
+    it_should_behave_like 'a chainable array-valued criteria clause', :all
+    it_should_behave_like 'a chainable array-valued criteria clause', :in
+    it_should_behave_like 'a chainable array-valued criteria clause', :nin
+
+    shared_examples_for 'an aliased method' do |aliased, method|
+      describe ":#{aliased}" do
+        it "should be an alias for :#{method}" do
+          subject.method( aliased ).should == subject.method( method )
+        end
+      end
+    end
+    
+    it_should_behave_like 'an aliased method', :and, :where
+    it_should_behave_like 'an aliased method', :all_in, :all
+    it_should_behave_like 'an aliased method', :any_in, :in
+        
+    describe ':exists' do
+      it 'should return a criteria' do
+        subject.exists( price: true ).should be_a( Opium::Model::Criteria )
+      end
+      
+      it 'should add a "$exist" clause for each hash pair, set to the truthiness of the pair value' do
+        subject.exists( price: true, title: 'no' ).tap do |criteria|
+          criteria.constraints.should have_key( 'where' )
+          criteria.constraints['where'].should =~ { 'price' => { '$exists' => true }, 'title' => { '$exists' => false } }
+        end
+      end
+    end
+    
+    describe '#between' do
+      context 'with a inclusive range' do
+        subject { Game.between( price: 5..10 ) }
+        
+        it { is_expected.to be_an( Opium::Model::Criteria ) }
+        
+        it { expect( subject.criteria.constraints ).to include(:where) }
+        
+        it 'adds a clause on the key' do
+          expect( subject.criteria.constraints[:where] ).to include(:price)
+        end
+        
+        it 'adds a "$gte" clause to the key' do
+          expect( subject.criteria.constraints[:where][:price] ).to include( '$gte' => 5 )
+        end
+        
+        it 'adds an "$lte" clause to the key' do
+          expect( subject.criteria.constraints[:where][:price] ).to include( '$lte' => 10 )
+        end
+        
+        it 'does not add an "$lt" clause to the key' do
+          expect( subject.criteria.constraints[:where][:price].keys ).to_not include( '$lt' )
+        end
+      end
+      
+      context 'with an exclusive range' do
+        subject { Game.between( price: 5...10 ) }
+        
+        it 'adds a "$gte" clause to the key' do
+          expect( subject.criteria.constraints[:where][:price] ).to include( '$gte' => 5 )
+        end
+        
+        it 'adds an "$lt" clause to the key' do
+          expect( subject.criteria.constraints[:where][:price] ).to include( '$lt' => 10 )
+        end
+        
+        it 'does not add an "$lte" clause to the key' do
+          expect( subject.criteria.constraints[:where][:price].keys ).to_not include( '$lte' )
+        end
+      end
+    end
+    
+    describe ':select' do
+      it 'should return a criteria' do
+        subject.select( title: subject.between( price: 5..10 ).keys( :title ) ).should be_a( Opium::Model::Criteria )
+      end
+      
+      it 'should add a "$select" clause for each hash key, setting the value to a query expression based off the pair-value criteria' do
+        subject.select( title: subject.between( price: 5..10 ).keys( :title ) ).tap do |criteria|
+          criteria.constraints.should have_key( 'where' )
+          criteria.constraints['where'].should =~ {
+            'title' => { '$select' => { 
+              'query' => { 'className' => 'Game', 'where' => { 'price' => { '$gte' => 5, '$lte' => 10 } } }, 
+              'key' => 'title' 
+              } }
+          }
+        end
+      end
+    end
+
+    describe ':dont_select' do
+      it 'should return a criteria' do
+        subject.dont_select( title: subject.between( price: 5..10 ).keys( :title ) ).should be_a( Opium::Model::Criteria )
+      end
+      
+      it 'should add a "$donSelect" clause for each hash key, setting the value to a query expression based off the pair-value criteria' do
+        subject.dont_select( title: subject.between( price: 5..10 ).keys( :title ) ).tap do |criteria|
+          criteria.constraints.should have_key( 'where' )
+          criteria.constraints['where'].should =~ {
+            'title' => { '$dontSelect' => { 
+              'query' => { 'className' => 'Game', 'where' => { 'price' => { '$gte' => 5, '$lte' => 10 } } }, 
+              'key' => 'title' 
+              } }
+          }
+        end
+      end
+    end
+    
+    describe ':or' do
+      it 'should return a criteria' do
+        subject.or( { title: 'Skyrim' }, { title: 'Oblivion' } ).should be_a( Opium::Model::Criteria )
+      end
+      
+      it 'should add an "$or" clause to the "where" constraint, whose contents are an array of all specified subqueries' do
+        subject.or( { title: 'Skyrim' }, { title: 'Oblivion' } ).tap do |criteria|
+          criteria.constraints.should have_key( 'where' )
+          criteria.constraints['where'].should =~ {
+            '$or' => [ { 'title' => 'Skyrim' }, { 'title' => 'Oblivion' } ]
+          }
+        end
+      end
+    end
+    
+    describe ':keys' do
+      it 'should return a criteria' do
+        subject.keys( :price ).should be_a( Opium::Model::Criteria )
+      end
+      
+      it 'should set the "keys" constraint to the provided set of fields, whose names should be parsized' do
+        subject.keys( :price, :updated_at ).tap do |criteria|
+          criteria.constraints.should have_key( 'keys' )
+          criteria.constraints['keys'].should == 'price,updatedAt'
+        end
+      end
+      
+      it 'should raise if a specified field does not exist' do
+        expect { subject.keys( :does_not_exist ) }.to raise_exception
+      end
+    end
+        
+    describe ':limit' do
+      it 'should return a criteria' do
+        subject.limit( 5 ).should be_a( Opium::Model::Criteria )
+      end
+      
+      it 'should set the "limit" constraint to the provided value' do
+        subject.limit( 100 ).tap do |criteria|
+          criteria.constraints.should have_key( 'limit' )
+          criteria.constraints['limit'].should == 100
+        end
+      end
+    end
+    
+    describe ':skip' do
+      it 'should return a criteria' do
+        subject.skip( 5 ).should be_a( Opium::Model::Criteria )
+      end
+      
+      it 'should set the "skip" constraint to the provided value' do
+        subject.skip( 100 ).tap do |criteria|
+          criteria.constraints.should have_key( 'skip' )
+          criteria.constraints['skip'].should == 100
+        end
+      end
+    end
+    
+    describe ':order' do
+      it 'should return a criteria' do
+        subject.order( title: :asc ).should be_a( Opium::Model::Criteria )
+      end
+      
+      it 'should set the "order" constraint to a string' do
+        subject.unscoped.order( title: :asc ).tap do |criteria|
+          criteria.constraints.should have_key( 'order' )
+          criteria.constraints['order'].should == 'title'
+        end
+      end
+      
+      it 'should negate the field if given something which evaluates to "desc", "-1", or "-"' do
+        [:desc, -1, '-'].each do |direction|
+          subject.unscoped.order( title: direction ).tap do |criteria|
+            criteria.constraints['order'].should == '-title'
+          end
+        end
+      end
+      
+      it 'should combine multiple orderings via a comma' do
+        subject.unscoped.order( title: 1, price: -1 ).tap do |criteria|
+          criteria.constraints['order'].should == 'title,-price'
+        end
+      end
+      
+      it 'should concatenate successive orderings' do
+        subject.unscoped.order( title: 1 ).order( price: -1 ).tap do |criteria|
+          criteria.constraints['order'].should == 'title,-price'
+        end
+      end
+    end
+    
+    describe ':cached?' do
+      it 'should be false on a non-cached criteria' do
+        Game.criteria.cached?.should be_falsey
+      end
+    end
+    
+    describe ':cache' do
+      after { subject.uncache }
+      
+      it 'should return a criteria' do
+        subject.cache.should be_an( Opium::Model::Criteria )
+      end
+      
+      it 'should cause :cached? to return true' do
+        subject.cache.cached?.should == true
+      end
+    end
+    
+    describe ':uncache' do
+      it 'should return a criteria' do
+        subject.uncache.should be_an( Opium::Model::Criteria )
+      end
+      
+      it 'should cause :cached? to return false' do
+        subject.uncache.cached?.should == false
+      end
+    end
+  end
+end

data/spec/opium/model/scopable_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper.rb'
+
+describe Opium::Model::Scopable do
+  let( :model ) { Class.new { include Opium::Model::Scopable } }
+  
+  describe 'the class' do
+    subject { model }
+    
+    it { should respond_to( :criteria ) }
+    it { should respond_to( :scope ).with(2).arguments }
+    it { should respond_to( :default_scope ).with(1).argument }
+    it { should respond_to( :scoped ) }
+    it { should respond_to( :unscoped ) }
+    it { should respond_to( :with_scope ).with(1).argument }
+  end
+  
+  describe 'within a model' do
+    before do
+      stub_const( 'Game', Class.new do |klass|
+        include Opium::Model
+        field :title, type: String
+        field :release_price, type: Float
+        
+        stub('model_name').and_return(ActiveModel::Name.new(klass, nil, 'Game'))
+        
+        default_scope order( title: :asc )
+        
+        scope :under_10, where( release_price: { '$lte' => 10.0 } )
+        scope :recent, -> { where( created_at: { '$gte' => Time.now - 3600 } ) }
+        scope :under do |limit|
+          where( release_price: { '$lte' => limit } )
+        end
+      end )
+    end
+    
+    describe ':criteria' do
+      it 'should be the :default_scope' do
+        Game.criteria.should == Game.default_scope 
+        Game.criteria.should == Game.criteria
+      end
+      
+      it 'should not be duplicated between calls' do
+        Game.criteria.should equal( Game.criteria )
+      end
+    end
+    
+    describe ':unscoped' do
+      it 'should return an empty Criteria' do
+        criteria = Game.unscoped
+        criteria.should be_a( Opium::Model::Criteria )
+        criteria.should_not be_constraints
+      end
+      
+      it 'if passed a block, should make scope calls within the block be unscoped, and return the result of the block' do
+        Game.default_scope.constraints.keys.should include('order')
+        criteria = Game.unscoped do
+          Game.limit( 10 ).tap do |inner|
+            inner.constraints.should =~ { 'limit' => 10, 'count' => 1 }
+          end
+        end
+        criteria.should be_a( Opium::Model::Criteria )
+        criteria.constraints.should =~ { 'limit' => 10, 'count' => 1 }
+        criteria.constraints.keys.should_not include('order')
+      end
+    end
+    
+    describe ':scope' do
+      it 'should create a method for each scope' do
+        Game.should respond_to( :under_10, :recent )
+        Game.should respond_to( :under ).with(1).argument 
+      end
+      
+      it 'each scope should be a criteria' do
+        Game.under_10.should be_a( Opium::Model::Criteria )
+        Game.recent.should be_a( Opium::Model::Criteria )
+        Game.under( 20 ).should be_a( Opium::Model::Criteria )
+      end
+      
+      it 'should not allow scopes without a criteria or block' do
+        expect { Game.scope :no_criteria_or_block }.to raise_exception(ArgumentError)
+      end
+    end
+    
+    describe ':default_scope' do
+      it 'should return a criteria if not given a parameter' do
+        Game.default_scope.should be_a( Opium::Model::Criteria )
+      end
+      
+      it 'should have a :model equal to its creating model' do
+        Game.default_scope.model_name.should == 'Game'
+      end
+      
+      it 'should set a criteria if passed one' do
+        expected = Game.unscoped
+        Game.default_scope( expected )
+        Game.default_scope.should == expected
+      end
+      
+      it 'should accept procs, which yield a criteria' do
+        expected = Game.unscoped.limit( 5 )
+        Game.default_scope( -> { Game.limit( 5 ) } ).should be_a( Opium::Model::Criteria )
+        Game.default_scope.should == expected
+      end
+      
+      it 'should accept a block, which yields a criteria' do
+        expected = Game.unscoped.limit( 5 )
+        Game.default_scope { Game.limit( 5 ) }.should be_a( Opium::Model::Criteria )
+        Game.default_scope.should == expected
+      end
+    end
+    
+    describe ':with_scope' do
+    end
+  end
+end

data/spec/opium/model/serialization_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Opium::Model::Serialization do
+  let( :model ) do
+    Class.new do
+      include Opium::Model
+      field :name
+      field :price
+    end
+  end
+  
+  it { model.should respond_to( :include_root_in_json ) }
+  it "include_root_in_json should default to false" do
+    model.include_root_in_json.should == false
+  end
+  
+  describe "instance" do
+    describe "with no data" do
+      let( :params ) { { "id" => nil, "created_at" => nil, "updated_at" => nil, "name" => nil, "price" => nil } }
+      subject { model.new }
+      its(:as_json) { should == params }
+      describe "to_json" do
+        it "should have no values in the JSON data" do
+          JSON.parse(subject.to_json).should include( params )
+        end
+      end
+    end
+    
+    describe "with partial data" do
+      let( :params ) { { "name" => "test", "price" => nil } }
+      subject { model.new( name: "test" ) }
+      its(:as_json) { should include( params ) }
+      describe "to_json" do
+        it "should have the set values in the JSON data" do
+          JSON.parse(subject.to_json).should include( params )
+        end
+      end
+    end
+    
+    describe "with full data" do
+      let( :params ) { { "name" => "test", "price" => 75.0 } }
+      subject { model.new( params ) }
+      its(:as_json) { should include( params ) }
+      describe "to_json" do
+        it "should have all values in the JSON data" do
+          JSON.parse(subject.to_json).should include( params )
+        end
+      end
+    end
+  end
+end

data/spec/opium/model_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Opium::Model do
+  before do
+    stub_const( 'Event', Class.new do
+      include Opium::Model
+      field :name, type: String
+      field :occurred_at, type: DateTime
+      field :severe, type: Boolean
+    end )
+  end
+  
+  subject { Event }
+  
+  it { should respond_to( :model_name, :validates, :define_model_callbacks ) }
+  it { should respond_to( :field ).with(2).arguments }
+  it { should respond_to( :delete_all, :find ).with(1).argument }
+  it { should respond_to( :connection ) }
+  it { should respond_to( :human_attribute_name, :lookup_ancestors ) }
+  
+  describe 'instance' do
+    subject { Event.new }
+    
+    it { should respond_to( :attributes ) }
+    it { should respond_to( :serializable_hash, :as_json, :from_json ) }
+    it { should respond_to( :changes, :changed? ) }
+    it { should respond_to( :inspect ) }
+    it { should respond_to( :to_key, :to_model ) }
+    
+    its(:attributes) do
+      should_not be_nil
+      should be_a_kind_of( Hash )
+    end
+  end
+  
+  describe 'inspect' do
+    describe 'within a blank model' do
+      subject { Event.new }
+      
+      it { subject.inspect.should == '#<Event id: nil, created_at: nil, updated_at: nil, name: nil, occurred_at: nil, severe: nil>' }
+    end
+    
+    describe 'within a model with data' do
+      let(:event_time) { Time.now }
+      subject { Event.new id: 'abc123', name: 'ping', occurred_at: event_time, severe: false }
+      it { subject.inspect.should == "#<Event id: \"abc123\", created_at: nil, updated_at: nil, name: \"ping\", occurred_at: #{event_time.to_datetime.inspect}, severe: false>" }
+    end
+  end
+end