json-crud-api 0.0.5 → 0.0.7

data/spec/unit/presenter_spec.rb

@@ -1,4 +1,4 @@
-require "helper"
+require "spec_helper"
 
 describe JsonCrudApi::Presenter do
   before(:each) do
@@ -13,9 +13,9 @@ describe JsonCrudApi::Presenter do
 
   describe '#initialize' do
     it 'should inject dependencies correctly' do
-      @presenter.model.should be @mock_model
-      @presenter.include.should eq({ :no_operation => 10 })
-      @presenter.exclude.should eq({ :no_operation => 11 })
+      expect(@presenter.model).to be @mock_model
+      expect(@presenter.include).to eq({ :no_operation => 10 })
+      expect(@presenter.exclude).to eq({ :no_operation => 11 })
     end
 
     it 'should throw an exception if model is not set' do
@@ -24,195 +24,216 @@ describe JsonCrudApi::Presenter do
 
   describe '#render' do
     it 'should output a single property in data based on model properties' do
-      @mock_model.should_receive(:properties)
+      expect(@mock_model).to receive(:properties)
         .and_return([OpenStruct.new(:name => :one)])
       data = OpenStruct.new(:one => "Test")
 
-      @presenter.render(data).should eq({ :one => "Test" })
+      expect(@presenter.render(data)).to eq({ :one => "Test" })
     end
 
     it 'should not return data properties that do not have model properties' do
-      @mock_model.should_receive(:properties)
+      expect(@mock_model).to receive(:properties)
         .and_return([OpenStruct.new(:name => :one)])
       data = OpenStruct.new(:one => "YES", :two => "OK")
 
-      @presenter.render(data).should eq({ :one => "YES" })
+      expect(@presenter.render(data)).to eq({ :one => "YES" })
     end
 
     it 'should return nil for model properties that do not have data' do
-      @mock_model.should_receive(:properties)
+      expect(@mock_model).to receive(:properties)
         .and_return([
           OpenStruct.new(:name => :one),
           OpenStruct.new(:name => :two),
         ])
       data = OpenStruct.new(:two => "OK")
 
-      @presenter.render(data).should eq({ :one => nil, :two => 'OK' })
+      expect(@presenter.render(data)).to eq({ :one => nil, :two => 'OK' })
     end
 
     it 'should call itself when supplied with an array and return an array of the results' do
-      @mock_model.stub :properties do
+      expect(@mock_model).to receive(:properties).and_return(
         [OpenStruct.new(:name => :one)]
-      end
+      )
+
       data = [OpenStruct.new(:one => "Test"), OpenStruct.new(:one => "TEST2")]
 
-      @presenter.render(data).should eq([{ :one => "Test" }, { :one => "TEST2" }])
+      expect(@presenter.render(data)).to eq([{ :one => "Test" }, { :one => "TEST2" }])
     end
 
     it 'should include render:all properties' do
       @presenter.include = { :render => { :all => [:five] } }
-      @mock_model.stub :properties do
+      expect(@mock_model).to receive(:properties).and_return(
         [OpenStruct.new(:name => :two)]
-      end
+      )
+      
       data = OpenStruct.new(:two => "Two",:five=>"Five")
 
-      @presenter.render(data).should eq({ :two => "Two", :five=>"Five" }) 
+      expect(@presenter.render(data)).to eq({ :two => "Two", :five=>"Five" }) 
     end
 
     it 'should include global:all properties' do
       @presenter.include = { :all => [:five] }
-      @mock_model.stub :properties do
-        [ OpenStruct.new(:name => :two)]
-      end
+      expect(@mock_model).to receive(:properties).and_return(
+        [OpenStruct.new(:name => :two)]
+      )
+
       data = OpenStruct.new(:two => "Two",:five=>"Five")
 
-      @presenter.render(data).should eq({ :two => "Two", :five=>"Five" }) 
+      expect(@presenter.render(data)).to eq({ :two => "Two", :five=>"Five" }) 
     end
 
     it 'should include global:operation properties' do
       @presenter.include = { :test => [:five] }
-      @mock_model.stub :properties do
-        [ OpenStruct.new(:name => :two)]
-      end
+      expect(@mock_model).to receive(:properties).and_return(
+        [OpenStruct.new(:name => :two)]
+      )
+
       data = OpenStruct.new(:two => "Two",:five=>"Five")
 
-      @presenter.render(data, :test).should eq({ :two => "Two", :five=>"Five" }) 
+      expect(@presenter.render(data, :test)).to eq({ :two => "Two", :five=>"Five" }) 
     end
 
     it 'should include render:operation properties' do
       @presenter.include = { :render => { :test => [:five] } }
-      @mock_model.stub :properties do
-        [ OpenStruct.new(:name => :two)]
-      end
+      expect(@mock_model).to receive(:properties).and_return(
+        [OpenStruct.new(:name => :two)]
+      )
+
       data = OpenStruct.new(:two => "Two",:five=>"Five")
 
-      @presenter.render(data, :test).should eq({ :two => "Two", :five=>"Five" }) 
+      expect(@presenter.render(data, :test)).to eq({ :two => "Two", :five=>"Five" }) 
     end
 
     it 'should exclude render:all properties' do
       @presenter.exclude = { :render => { :all => [:one] } }
-      @mock_model.stub :properties do
-        [OpenStruct.new(:name => :one), OpenStruct.new(:name => :two)]
-      end
+      expect(@mock_model).to receive(:properties).and_return(
+        [OpenStruct.new(:name => :two)]
+      )
+
       data = OpenStruct.new(:one => "Test",:two => "Two")
 
-      @presenter.render(data).should eq({ :two => "Two" }) 
+      expect(@presenter.render(data)).to eq({ :two => "Two" }) 
     end
 
     it 'should exclude global:all properties' do
       @presenter.exclude = { :all => [:one] }
-      @mock_model.stub :properties do
+      expect(@mock_model).to receive(:properties).and_return(
         [OpenStruct.new(:name => :one), OpenStruct.new(:name => :two)]
-      end
+      )
+
       data = OpenStruct.new(:one => "Test",:two => "Two")
 
-      @presenter.render(data).should eq({ :two => "Two" }) 
+      expect(@presenter.render(data)).to eq({ :two => "Two" }) 
     end
 
     it 'should exclude render:operation properties' do
       @presenter.exclude = { :render => { :test => [:one] } }
-      @mock_model.stub :properties do
+      expect(@mock_model).to receive(:properties).and_return(
         [OpenStruct.new(:name => :one), OpenStruct.new(:name => :two)]
-      end
+      )
+
       data = OpenStruct.new(:one => "Test",:two => "Two")
 
-      @presenter.render(data, :test).should eq({ :two => "Two" }) 
+      expect(@presenter.render(data, :test)).to eq({ :two => "Two" }) 
     end
 
     it 'should exclude global:operation properties' do
       @presenter.exclude = { :test => [:one] }
-      @mock_model.stub :properties do
+      expect(@mock_model).to receive(:properties).and_return(
         [OpenStruct.new(:name => :one), OpenStruct.new(:name => :two)]
-      end
+      )
+
       data = OpenStruct.new(:one => "Test",:two => "Two")
 
-      @presenter.render(data, :test).should eq({ :two => "Two" }) 
+      expect(@presenter.render(data, :test)).to eq({ :two => "Two" }) 
     end
 
     it 'should exclude combinations of render:all and render:operation properties' do
       @presenter.exclude = { :render => { :all => [:two] , :test => [:one] } }
-      @mock_model.stub :properties do
+      expect(@mock_model).to receive(:properties).and_return(
         [OpenStruct.new(:name => :one), OpenStruct.new(:name => :two), OpenStruct.new(:name => :three)]
-      end
+      )
       data = OpenStruct.new(:one => "Test",:two => "Two",:three => "Three")
 
-      @presenter.render(data, :test).should eq({ :three => "Three" }) 
+      expect(@presenter.render(data, :test)).to eq({ :three => "Three" }) 
     end
   end
 
   describe '#parse' do
     it 'should output a single property in data based on model properties' do
-      @mock_model.stub :properties do
+      expect(@mock_model).to receive(:properties).and_return(
         [OpenStruct.new(:name => :one)]
-      end
+      )
       data = { :one => 1 }
-      @presenter.parse(data).should eq({:one => 1})
+      expect(@presenter.parse(data)).to eq({:one => 1})
     end
 
     it 'should not output properties of data that are not in model properties' do
-      @mock_model.stub :properties do
+      expect(@mock_model).to receive(:properties).and_return(
         [OpenStruct.new(:name => :one)]
-      end
+      )
       data = { :one => 1, :two => 2 }
-      @presenter.parse(data).should eq({:one => 1})
+      expect(@presenter.parse(data)).to eq({:one => 1})
     end
 
     it 'should not output model properties with no data property' do
-      @mock_model.stub :properties do
-        [OpenStruct.new(:name => :one)]
-        [OpenStruct.new(:name => :two)]
-      end
+      expect(@mock_model).to receive(:properties).and_return(
+        [OpenStruct.new(:name => :one),OpenStruct.new(:name => :two)]
+      )
       data = { :two => 2 }
-      @presenter.parse(data).should eq({:two => 2})
+      expect(@presenter.parse(data)).to eq({:two => 2})
     end
 
     it 'should call itself when supplied with an array and return an array of the results' do
-      @mock_model.stub :properties do
+      expect(@mock_model).to receive(:properties).and_return(
         [OpenStruct.new(:name => :one)]
-      end
+      )
+
       data = [{ :one => 1 }]
 
-      @presenter.parse(data).should eq([{ :one => 1 }])
+      expect(@presenter.parse(data)).to eq([{ :one => 1 }])
     end
 
     it 'should exclude parse:all properties' do
       @presenter.exclude = { :parse => { :all => [:one] } }
-      @mock_model.stub :properties do
+      expect(@mock_model).to receive(:properties).and_return(
         [OpenStruct.new(:name => :one), OpenStruct.new(:name => :two)]
-      end
+      )
+
       data = OpenStruct.new(:one => "Test",:two => "Two")
 
-      @presenter.parse(data).should eq({ :two => "Two" }) 
+      expect(@presenter.parse(data)).to eq({ :two => "Two" }) 
     end
 
     it 'should exclude parse:operation properties' do
       @presenter.exclude = { :parse => { :test => [:one] } }
-      @mock_model.stub :properties do
+      expect(@mock_model).to receive(:properties).and_return(
         [OpenStruct.new(:name => :one), OpenStruct.new(:name => :two)]
-      end
+      )
+
       data = OpenStruct.new(:one => "Test",:two => "Two")
 
-      @presenter.parse(data, :test).should eq({ :two => "Two" }) 
+      expect(@presenter.parse(data, :test)).to eq({ :two => "Two" }) 
     end
 
     it 'should exclude combinations of parse:all and parse:operation properties' do
       @presenter.exclude = { :parse => { :all => [:two] , :test => [:one] } }
-      @mock_model.stub :properties do
+      expect(@mock_model).to receive(:properties).and_return(
         [OpenStruct.new(:name => :one), OpenStruct.new(:name => :two), OpenStruct.new(:name => :three)]
-      end
+      )
       data = OpenStruct.new(:one => "Test",:two => "Two",:three => "Three")
 
-      @presenter.parse(data, :test).should eq({ :three => "Three" }) 
+      expect(@presenter.parse(data, :test)).to eq({ :three => "Three" }) 
+    end
+
+    it 'should not supply keys that are not in the supplied data' do
+      expect(@mock_model).to receive(:properties).and_return(
+        [OpenStruct.new(:name => :one), OpenStruct.new(:name => :two), OpenStruct.new(:name => :three)]
+      )
+
+      data = OpenStruct.new(:one => "Test",:two => "Two")
+
+      expect(@presenter.parse(data, :test).keys).to_not include :three
     end
   end
 end

data/spec/unit/service_spec.rb

@@ -1,4 +1,4 @@
-require "helper"
+require "spec_helper"
 
 describe JsonCrudApi::Service do
   before(:each) do
@@ -15,215 +15,215 @@ describe JsonCrudApi::Service do
 
   describe '#initialize' do
     it 'should inject dependencies correctly' do
-      @service.log_service.should be @mock_log
-      @service.model.should be @mock_model
-      @service.scope_map.should be @mock_map
+      expect(@service.log_service).to be @mock_log
+      expect(@service.model).to be @mock_model
+      expect(@service.scope_map).to be @mock_map
     end
 
     it 'should initialize user and scopes to nil' do
-      @service.user.should be nil
-      @service.user_scopes.should be nil
+      expect(@service.user).to be nil
+      expect(@service.user_scopes).to be nil
     end
   end
 
   describe '#create' do
     it 'should call create on model with params' do
       params = { :one => 'one', :two => 'two' }
-      @mock_model.should_receive(:create).with(params).and_return(2)
-      @service.create(params).should eq 2
+      expect(@mock_model).to receive(:create).with(params).and_return(2)
+      expect(@service.create(params)).to eq 2
     end
   end
 
   describe '#exists?' do
     it 'should call all on model with correct id' do
       query_object = OpenStruct.new :count => 1
-      @mock_model.should_receive(:key)
+      expect(@mock_model).to receive(:key)
         .and_return(OpenStruct.new(:first => OpenStruct.new(:name => :id)))
-      @mock_model.should_receive(:all).with(:id => 3)
+      expect(@mock_model).to receive(:all).with(:id => 3)
         .and_return(query_object)
-      @service.exists?(3).should eq true
+      expect(@service.exists?(3)).to eq true
     end
 
     it 'should return false when count is zero' do
       query_object = OpenStruct.new :count => 0
-      @mock_model.should_receive(:key)
+      expect(@mock_model).to receive(:key)
         .and_return(OpenStruct.new(:first => OpenStruct.new(:name => :id)))
-      @mock_model.should_receive(:all).with(:id => 3)
+      expect(@mock_model).to receive(:all).with(:id => 3)
         .and_return(query_object)
-      @service.exists?(3).should eq false
+      expect(@service.exists?(3)).to eq false
     end
 
     it 'should return true when count is one' do
       query_object = OpenStruct.new :count => 1
-      @mock_model.should_receive(:key)
+      expect(@mock_model).to receive(:key)
         .and_return(OpenStruct.new(:first => OpenStruct.new(:name => :id)))
-      @mock_model.should_receive(:all).with(:id => 3)
+      expect(@mock_model).to receive(:all).with(:id => 3)
         .and_return(query_object)
-      @service.exists?(3).should eq true
+      expect(@service.exists?(3)).to eq true
     end
 
     it 'should return true when count is more than one' do
       query_object = OpenStruct.new :count => 2
-      @mock_model.should_receive(:key)
+      expect(@mock_model).to receive(:key)
         .and_return(OpenStruct.new(:first => OpenStruct.new(:name => :id)))
-      @mock_model.should_receive(:all).with(:id => 3)
+      expect(@mock_model).to receive(:all).with(:id => 3)
       .and_return(query_object)
-      @service.exists?(3).should eq true
+      expect(@service.exists?(3)).to eq true
     end
   end
 
   describe '#get_all' do
     it 'should call all on model and return output' do
-      @mock_model.should_receive(:all).with().and_return(67)
-      @service.get_all.should eq 67
+      expect(@mock_model).to receive(:all).and_return(67)
+      expect(@service.get_all).to eq 67
     end
   end
 
   describe '#get' do
     it 'should call first on model with correct id and return result' do
-        @mock_model.should_receive(:key)
+        expect(@mock_model).to receive(:key)
           .and_return(OpenStruct.new(:first => OpenStruct.new(:name => :id)))
-        @mock_model.should_receive(:first).with({:id=>8}).and_return(123)
-      @service.get(8).should eq 123
+        expect(@mock_model).to receive(:first).with({:id=>8}).and_return(123)
+      expect(@service.get(8)).to eq 123
     end
   end
 
   describe '#update' do
     it 'should call get on service with correct id' do
-      @service.should_receive(:get).with(5).and_return(nil)
+      expect(@service).to receive(:get).with(5).and_return(nil)
       @service.update(5,nil)
     end
 
     it 'should return false if get returns nil' do
-      @service.should_receive(:get).with(5).and_return(nil)
-      @service.update(5,nil).should eq false
+      expect(@service).to receive(:get).with(5).and_return(nil)
+      expect(@service.update(5,nil)).to eq false
     end
 
     it 'should call update on record with correct params' do
       params = { :one => 'one', :two => 'two' }
       record = double('entity')
-      @service.should_receive(:get).with(5)
+      expect(@service).to receive(:get).with(5)
       .and_return(record)
-      record.should_receive(:update).with(params)
+      expect(record).to receive(:update).with(params)
       .and_return(789)
-      @service.update(5,params).should eq 789
+      expect(@service.update(5,params)).to eq 789
     end
   end
 
   describe '#delete' do
     it 'should call get on service with correct id' do
-      @service.should_receive(:get).with(5).and_return(nil)
+      expect(@service).to receive(:get).with(5).and_return(nil)
       @service.delete(5)
     end
 
     it 'should return false if get returns nil' do
-      @service.should_receive(:get).with(5).and_return(nil)
-      @service.delete(5).should eq false
+      expect(@service).to receive(:get).with(5).and_return(nil)
+      expect(@service.delete(5)).to eq false
     end
 
     it 'should call delete on record' do
       record = double('entity')
-      @service.should_receive(:get).with(5)
+      expect(@service).to receive(:get).with(5)
       .and_return(record)
-      record.should_receive(:destroy).and_return(109)
-      @service.delete(5).should eq 109
+      expect(record).to receive(:destroy).and_return(109)
+      expect(@service.delete(5)).to eq 109
     end
   end
 
   describe '#set_user' do
     it 'should set user in service to param' do
       @service.set_user(nil)
-      @service.user.should eq nil
+      expect(@service.user).to eq nil
     end
 
     it 'should not call set_user_scopes if user is nil' do
-      @service.should_not_receive(:set_user_scopes)
+      expect(@service).not_to receive(:set_user_scopes)
       @service.set_user(nil)
-      @service.user.should eq nil
+      expect(@service.user).to eq nil
     end
 
     it 'should call set_user_scopes if user is not' do
       user = { :scopes => [1,2] }
-      @service.should_receive(:set_user_scopes).with([1,2])
+      expect(@service).to receive(:set_user_scopes).with([1,2])
       @service.set_user(user)
-      @service.user.should eq user
+      expect(@service.user).to eq user
     end
   end
 
   describe '#set_user_scopes' do
     it 'should set user_scopes in service to param' do
       @service.set_user_scopes(nil)
-      @service.user_scopes.should eq nil
+      expect(@service.user_scopes).to eq nil
 
       @service.set_user_scopes(234234)
-      @service.user_scopes.should eq 234234
+      expect(@service.user_scopes).to eq 234234
     end
   end
 
   describe '#user_authorized_for?' do
     it 'should return true if scope_map is nil' do
       @service.scope_map = nil
-      @service.user_authorized_for?(:one).should be true
+      expect(@service.user_authorized_for?(:one)).to be true
     end
 
     it 'should return true if scope_map is not nil but no map for operation' do
       @service.scope_map = { :two => 'TWO' }
-      @service.user_authorized_for?(:one).should be true
+      expect(@service.user_authorized_for?(:one)).to be true
     end
 
     it 'should return false if user is nil' do
       @service.scope_map = { :two => 'TWO' }
       @service.user = nil
-      @service.user_authorized_for?(:two).should be false
+      expect(@service.user_authorized_for?(:two)).to be false
     end
 
     it 'should return false if user has nil scopes' do
       @service.scope_map = { :two => 'TWO' }
       @service.user = { :name => "Tom" }
       @service.user_scopes = nil
-      @service.user_authorized_for?(:two).should be false
+      expect(@service.user_authorized_for?(:two)).to be false
     end
 
     it 'should return false if user has empty scopes' do
       @service.scope_map = { :two => 'TWO' }
       @service.user = { :name => "Tom" }
       @service.user_scopes = []
-      @service.user_authorized_for?(:two).should be false
+      expect(@service.user_authorized_for?(:two)).to be false
     end
 
     it 'should return true if scope map exists in user scopes' do
       @service.scope_map = { :two => 'FIVE'}
       @service.user = { :name => "Tom" }
       @service.user_scopes = [ 'ONE', 'TWO', 'FIVE']
-      @service.user_authorized_for?(:two).should be true
+      expect(@service.user_authorized_for?(:two)).to be true
     end
 
     it 'should return false if scope map does not exist in user scopes' do
       @service.scope_map = { :two => 'SEVEN'}
       @service.user = { :name => "Tom" }
       @service.user_scopes = [ 'ONE', 'TWO', 'FIVE']
-      @service.user_authorized_for?(:two).should be false
+      expect(@service.user_authorized_for?(:two)).to be false
     end
 
     it 'should return true if scope map is array and shares one scope with user' do
       @service.scope_map = { :two => ['TWO'] }
       @service.user = { :name => "Tom" }
       @service.user_scopes = [ 'ONE', 'TWO', 'THREE']
-      @service.user_authorized_for?(:two).should be true
+      expect(@service.user_authorized_for?(:two)).to be true
     end
 
     it 'should return true if scope map is array and shares more than one scope with user' do
       @service.scope_map = { :two => ['TWO','THREE'] }
       @service.user = { :name => "Tom" }
       @service.user_scopes = [ 'ONE', 'TWO', 'THREE']
-      @service.user_authorized_for?(:two).should be true
+      expect(@service.user_authorized_for?(:two)).to be true
     end
 
     it 'should return false if scope map is array and does not share scopes with user' do
       @service.scope_map = { :two => ['FOUR'] }
       @service.user = { :name => "Tom" }
       @service.user_scopes = [ 'ONE', 'TWO', 'THREE']
-      @service.user_authorized_for?(:two).should be false
+      expect(@service.user_authorized_for?(:two)).to be false
     end
   end
 end