acts_as_sdata 1.0.0

data/test/unit/controller_mixin/sdata_scope/scoping_in_config_spec.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe SData::ControllerMixin, "#sdata_scope" do
+  context "given a controller which acts as sdata and accesses a linked model" do
+    context "being configured with user scoping" do
+      before :all do
+        BaseModel = Class.new(ActiveRecord::Base)
+
+        Object.__send__ :remove_const, :Model if defined?(Model)
+        class Model < SData::VirtualBase
+          self.baze_class = BaseModel
+
+          define_payload_map :born_at => { :baze_field => :born_at }
+
+          acts_as_sdata :link => :simply_guid
+        end
+
+        class Controller < ActionController::Base
+          extend SData::ControllerMixin
+
+          acts_as_sdata  :model => Model, :feed =>
+                           {:author => 'Billing Boss',
+                            :path => '/trading_accounts',
+                            :title => 'Billing Boss | Trading Accounts',
+                            :default_items_per_page => 10,
+                            :maximum_items_per_page => 100},
+                            :scoping => ["created_by_id = ?"]
+        end
+      end
+
+      before :each do
+        @user = User.new.populate_defaults
+        @controller = Controller.new
+        Model.stub! :all => []
+      end
+
+      context "with no other params" do
+        before :each do
+          @controller.stub! :params => {}
+          @controller.stub! :current_user => @user
+          @controller.stub! :target_user => @user
+        end
+
+        it "should return all entity records created_by scope" do
+          Model.should_receive(:all).with :conditions => ['created_by_id = ?', "#{@user.id}"]
+          @controller.send :sdata_scope
+        end
+      end
+
+      context "with condition and where clause" do
+        before :each do
+          @controller.stub! :params => { 'where born_at gt 1900' => nil, :condition => '$linked' }
+          @controller.stub! :current_user => @user
+          @controller.stub! :target_user => @user
+        end
+
+        it "should return all entity records with created_by, predicate, and link scope" do
+          Model.should_receive(:all).with :conditions => ['"born_at" > ? and created_by_id = ? and id IN (SELECT bb_model_id FROM sd_uuids WHERE bb_model_type = \'BaseModel\' and sd_class = \'Model\')', '1900', @user.id.to_s]
+          @controller.send :sdata_scope
+        end
+      end
+    end
+  end
+end

data/test/unit/controller_mixin/sdata_show_instance_spec.rb

@@ -0,0 +1,98 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+include SData
+
+describe ControllerMixin, "#sdata_show_instance" do
+  module Sage
+    module BusinessLogic
+      module Exception
+        class AccessDeniedException < StandardError
+          
+        end
+      end
+    end
+  end
+  describe "given a controller which acts as sdata" do
+    before :all do
+     Base = Class.new(ActionController::Base)
+     Base.extend ControllerMixin
+    end
+    describe "given a model without baze" do
+      before :all do
+        Model = Class.new
+        Base.acts_as_sdata  :model => Model
+      end
+  
+      before :each do
+        @controller = Base.new
+      end
+  
+      describe "when params contain :instance_id key" do
+        before :each do
+          @instance_id = 1
+          @controller.stub! :params => { :instance_id => @instance_id },
+                            :current_user => OpenStruct.new(:sage_username => 'bob', :id => 1),
+                            :target_user => OpenStruct.new(:sage_username => 'bob', :id => 1),
+                            :logged_in? => true
+        end
+  
+#        describe "when record with such id exists and belongs to user" do
+#          before :each do
+#            @record = Model.new
+#            @record.stub! :owner => OpenStruct.new(:sage_username => 'bob', :id => 1)
+#            Model.should_receive(:find_by_sdata_instance_id).with(@instance_id).and_return(@record)
+#          end
+#  
+#          it "should render atom entry of the record" do
+#            entry = Atom::Entry.new
+#            @record.should_receive(:to_atom).and_return(entry)
+#            @controller.should_receive(:render).with(:xml => entry, :content_type => "application/atom+xml; type=entry")
+#            @controller.sdata_show_instance
+#          end
+#        end
+
+        describe "when record with such id exists but does not belong to user" do
+          before :each do
+            @record = Model.new
+            @record.stub! :owner => OpenStruct.new(:sage_username => 'mary', :id => 2)
+            Model.should_receive(:find_by_sdata_instance_id).with(@instance_id).and_return(@record)
+          end
+  
+          it "should render atom entry of the record" do
+            # Can't get raise_error to work properly :/
+            entry = Atom::Entry.new
+            @controller.should_receive(:handle_exception)
+            @controller.sdata_show_instance
+          end
+        end
+  
+        describe "when record with such id does not exist" do
+          before :each do
+            Model.should_receive(:find_by_sdata_instance_id).with(@instance_id).and_return(nil)
+          end
+  
+          it "should..." do
+            pending "wasn't defined yet"
+          end
+        end
+      end
+  
+      describe "whem params does not contain :instance_id key" do
+        before :each do
+          @controller.stub! :params => Hash.new
+        end
+  
+        it "should..." do
+          pending "wasn't defined yet"
+        end
+      end
+    end
+    
+    describe "given a model with baze" do
+      it "should ..." do
+        pending "not yet tested"
+      end
+
+    end
+  end
+end

data/test/unit/controller_mixin/sdata_update_instance_spec.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+include SData
+
+describe ControllerMixin, "#sdata_update_instance" do
+    class BaseClass
+      attr_accessor :status
+      def id
+        1
+      end
+      
+      def self.find(*params)
+        self.new
+      end
+      
+      def update_attributes(*params)
+        self.status = :updated
+        self
+      end
+    end
+
+    class VirtualModel < SData::VirtualBase
+      attr_accessor :baze
+    end
+    
+    before :all do
+      VirtualModel.stub :baze_class => BaseClass
+      Base = Class.new(ActionController::Base)
+      Base.extend ControllerMixin
+      Base.acts_as_sdata  :model => VirtualModel
+      VirtualModel.acts_as_sdata
+    end
+
+    before :each do
+      pending # not currently supported
+      @controller = Base.new
+    end  
+
+    describe "given params contain Atom::Entry" do
+      before :each do
+        @entry = Atom::Entry.new
+        @controller.stub!  :params => { :entry => @entry, :instance_id => 1},
+                                        :response => OpenStruct.new,
+                                        :request => OpenStruct.new(:fresh? => true)
+        
+        @model = VirtualModel.new(BaseClass.new)
+        VirtualModel.should_receive(:new).and_return @model
+      end
+
+      describe "when update is successful" do
+        before :each do
+          @model.baze.stub! :save => true
+          @model.stub! :to_atom => stub(:to_xml => '<entry></entry>')
+        end
+
+        it "should respond with updated" do
+          @controller.should_receive(:render) do |args|
+            #TODO: what should I check for?.. Returns 1 right now, is this right?
+          end
+          @controller.sdata_update_instance
+        end
+      end
+    end
+end
+

data/test/unit/payload_map/payload_map_hash_spec.rb

@@ -0,0 +1,84 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+include SData::PayloadMap
+
+describe PayloadMapHash do
+  context "given a hash with payload map" do
+    before :each do
+      @hash = {
+        :taxation_country       => { :baze_field => :country, :precedence => 3 },
+        :short_name             => { :baze_field => :name, :precedence => 3 },
+
+        :company_person_flag    => { :static_value => 'Company', :precedence => 50 },
+        :customer_supplier_flag => { :static_value => 'Customers', :precedence => 50 },
+        :nil_value              => { :static_value => nil, :precedence => 50 },
+        :false_value              => { :static_value => false, :precedence => 50 },
+
+        :billing_addresses      => { :proc => lambda { SData::PostalAddress.build_for([self.baze], :billing) }, 
+                                     :precedence => 3},
+                                     
+        :thingy_with_deleted    => { :proc => lambda { SData::PostalAddress.build_for([self.baze], :billing) }, 
+                                     :precedence => 3,
+                                     :proc_with_deleted => lambda { puts "I am a lambda" } }
+      }
+    end
+
+    context "when PayloadMapHash is initialized with such hash" do
+      subject { PayloadMapHash.new(@hash) }
+
+      it { should be_kind_of(Hash) }
+
+      describe "#static_values" do
+        it "should return only staic values as a key-value hash" do
+          subject.static_values.should == {
+            :company_person_flag => 'Company',
+            :customer_supplier_flag => 'Customers',
+            :false_value => false,
+            :nil_value => nil
+          }
+        end
+      end
+
+      describe "#baze_fields" do
+        it "should return only baze fields as a key-value hash" do
+          subject.baze_fields.should == {
+            :taxation_country => :country,
+            :short_name => :name
+          }
+        end
+      end
+
+      describe "#attrs" do
+        it "should return attrs as union of static_values & baze_fields" do
+          subject.attrs.should == {
+            :taxation_country       => { :baze_field => :country, :precedence => 3 },
+            :short_name             => { :baze_field => :name, :precedence => 3 },
+
+            :company_person_flag    => { :static_value => 'Company', :precedence => 50 },
+            :customer_supplier_flag => { :static_value => 'Customers', :precedence => 50 },
+            :false_value              => { :static_value => false, :precedence => 50 },
+            :nil_value              => { :static_value => nil, :precedence => 50 }
+          }
+        end
+      end
+
+      describe "#procs" do
+        it "should return only stored procs as a field_name-proc hash" do
+          subject.procs.should == {
+            :billing_addresses => @hash[:billing_addresses][:proc],
+            :thingy_with_deleted => @hash[:thingy_with_deleted][:proc]
+          }
+        end
+      end
+
+      describe "#procs_with_deleted" do
+        it "should return proc_with_deleted or otherwise proc as a field_name-proc hash" do
+          subject.procs_with_deleted.should == {
+            :billing_addresses => @hash[:billing_addresses][:proc],
+            :thingy_with_deleted => @hash[:thingy_with_deleted][:proc_with_deleted]
+          }
+        end
+      end
+    end
+  end
+end

data/test/unit/payload_map/payload_map_spec.rb

@@ -0,0 +1,144 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe SData::PayloadMap do
+  context "given sdata model class extended by SData::PayloadMap" do
+    before :all do
+      class TradingAccount < SData::VirtualBase
+#        extend SData::PayloadMap
+#
+        define_payload_map :foo => { :static_value => :bar }
+
+        # temporary
+        def method_missing(meth, *args, &block)
+          if @payload
+            @payload.send(meth, *args, &block)
+          else
+            super
+          end      
+        end
+      end
+    end
+
+    it "should respond to #payload_map class method" do
+      TradingAccount.should respond_to(:define_payload_map)
+    end
+
+    it "should respond to #has_sdata_attr class method" do
+      TradingAccount.should respond_to(:has_sdata_attr)
+      #QUESTION: do we really need this method to be public?
+    end
+
+    describe "#define_payload_map" do
+      context "when mapping leads to static value" do
+        before :each do
+          TradingAccount.define_payload_map :tax_reference => { :static_value => 'Some static tax reference' }
+        end
+
+        subject { TradingAccount.new(Object) }
+
+        it { should respond_to(:payload) }
+
+        context "when correspondent field method is called" do
+          it "should return given static value" do
+            subject.tax_reference.should == 'Some static tax reference'
+          end
+        end
+
+        describe "#payload_map" do
+          it "should store it correctly" do
+            subject.payload_map[:tax_reference].should == { :static_value => 'Some static tax reference', :method_name => :tax_reference, :method_name_with_deleted=>:tax_reference}
+          end
+        end
+      end
+
+      context "when mapping leads to a baze field" do
+        before :each do
+          @baze = Struct.new(:country).new('Kyrgyzstan')
+
+          TradingAccount.baze_class = Customer
+          TradingAccount.define_payload_map :taxation_country => { :baze_field => :country }
+        end
+
+        subject { TradingAccount.new(@baze) }
+
+        it "should apply to baze class" do
+          subject.taxation_country.should == @baze.country
+        end
+
+        it "should not cache value, but fetch it each time" do
+          @baze.country = 'Canada'
+          subject.taxation_country.should == 'Canada'
+        end
+      end
+
+      context "when mapping leads to a proc" do
+        before :each do
+          @mock = mock("thing", :dynamic => 1, :dynamic_deleted => 3)
+          mock = @mock
+          TradingAccount.define_payload_map :dynamic_field => { :proc => lambda { mock.dynamic }, :proc_with_deleted  => lambda { mock.dynamic_deleted }}
+        end
+
+        subject { TradingAccount.new(Object) }
+
+        it "should call given lambda each time" do
+          @mock.should_receive(:dynamic).twice
+          2.times { subject.dynamic_field }
+        end
+
+        it "should return lambda's return value" do
+          expected_return_value = 123456
+          @mock.stub! :dynamic => expected_return_value
+          subject.dynamic_field.should == expected_return_value
+        end
+
+        it "should set the method_name in the options to the attribute name" do
+          subject.payload_map[:dynamic_field][:method_name].should == :dynamic_field
+        end
+        
+        it "should create a xxx_with_deleted method" do
+          expected_return_value = 498
+          @mock.stub! :dynamic_deleted => expected_return_value
+          subject.dynamic_field_with_deleted.should == expected_return_value
+        end
+        
+        context "consider lambda calls local object methods" do
+          before :each do
+            TradingAccount.__send__ :attr_accessor, :local_field
+            TradingAccount.define_payload_map :access_to_local_field => { :proc => lambda { self.local_field } }
+          end
+
+          subject { TradingAccount.new(Object) }
+
+          it "should run lambda in context of SData model object" do
+            subject.local_field = 654321
+            subject.access_to_local_field.should == 654321
+          end
+        end
+      end
+    end
+
+    describe "#has_sdata_attr" do
+      before :each do
+        @mock_baze = mock("thing", :dude => "sweet")
+      end
+
+      subject { TradingAccount.new(@mock_baze) }
+
+      it "should add a static value attr" do
+        TradingAccount.has_sdata_attr :some_static_value, { :static_value => 42 }
+        subject.some_static_value.should == 42
+      end
+
+      it "should add a static value attr whose value is nil" do
+        TradingAccount.has_sdata_attr :some_nil, { :static_value => nil }
+        subject.some_nil.should be_nil
+      end
+
+      it "should add a baze_field attr" do
+        TradingAccount.has_sdata_attr :some_baze_value, { :baze_field => :dude }
+        subject.some_baze_value.should == "sweet"
+      end
+      
+    end
+  end
+end