smooth_operator 1.3.0 → 1.8.0

data/spec/smooth_operator/attribute_assignment_spec.rb

@@ -5,27 +5,6 @@ describe SmoothOperator::AttributeAssignment do
 
   describe "#assign_attributes" do
 
-    describe "receiving data from server" do
-      subject { User::Base.new }
-
-      context "when receiving a Hash with meta_data on it" do
-        before { subject.assign_attributes({ user: attributes_for(:user), status: 1 }) }
-
-        it "#meta_data should reflect the receiving meta_data" do
-          expect(subject._meta_data).to eq({ "status" => 1 })
-        end
-
-        it "subject should NOT contain meta_data" do
-          expect{ subject.status }.to raise_error NoMethodError
-        end
-
-        it "subject should contain all other data" do
-          expect(subject.attributes).to eq(attributes_for(:user))
-        end
-      end
-
-    end
-
     describe "white and black list" do
       subject { UserWithAddressAndPosts::Son.new(attributes_for(:user_with_address_and_posts)) }
 
@@ -55,28 +34,14 @@ describe SmoothOperator::AttributeAssignment do
     context "when something other than a hash is introduced" do
       it "should do nothing" do
         [nil, '', [1, 2], 'test', 1, 2].each do |something_other_than_a_hash|
-          expect(User::Base.new(something_other_than_a_hash).internal_data).to eq({})
+          expect(User.new(something_other_than_a_hash).internal_data).to eq({})
         end
       end
     end
 
     context "when one of the attribute's value, is an hash and is unknown to the schema" do
-      context "when the .unknown_hash_class is unused", current: true do
-        subject { User::Base.new(address: { street: 'something', postal_code: { code: '123' } }) }
-
-        it "a new instance of OpenStruct will be initialized with that hash" do
-          address = subject.address
-
-          expect(address).to be_instance_of(OpenStruct)
-          expect(address.street).to eq('something')
-
-          expect(address.postal_code).to be_instance_of(OpenStruct)
-          expect(address.postal_code.code).to eq('123')
-        end
-      end
-
-      context "when the .unknown_hash_class is set to SmoothOperator::OpenStruct" do
-        subject { User::UnknownHashClass::OpenStructBase.new(address: { street: 'something', postal_code: { code: '123' } }) }
+      context "when the .turn_unknown_hash_to_open_struct is set to true or unused" do
+        subject { User.new(address: { street: 'something', postal_code: { code: '123' } }) }
 
         it "a new instance of SmoothOperator::OpenStruct will be initialized with that hash" do
           address = subject.address
@@ -88,9 +53,9 @@ describe SmoothOperator::AttributeAssignment do
           expect(address.postal_code.code).to eq('123')
         end
       end
-
-      context "when the .unknown_hash_class is set to nil" do
-        subject { User::UnknownHashClass::None.new(creator: { first_name: 'admin', address: { street: 'something' } }) }
+        
+      context "when the .turn_unknown_hash_to_open_struct is set to false", current: true do
+        subject { Post.new(creator: { first_name: 'admin', address: { street: 'something' } }) }
 
         it "the hash will be copied as it is" do
           creator = subject.creator
@@ -105,7 +70,7 @@ describe SmoothOperator::AttributeAssignment do
     end
 
     context "when there is no declared schema" do
-      subject { User::Base.new(attributes_for(:user)) }
+      subject { User.new(attributes_for(:user)) }
       let(:expected_internal_data) { SmoothOperator::Helpers.stringify_keys(attributes_for(:user)) }
 
       it "it should populate 'internal_data' with unaltered duplicate data from the received hash" do
@@ -120,34 +85,6 @@ describe SmoothOperator::AttributeAssignment do
     context "when there is a known schema and the received hash has an attribute" do
       subject { UserWithAddressAndPosts::Son }
 
-      context "that is declared (in schema) as an nil" do
-
-        it "when the attributes's value is '1', should return '1'" do
-          expect(subject.new(complex_field: '1').complex_field).to eq('1')
-        end
-
-        it "when the attributes's value is ['1', '2'], should return ['1', '2']" do
-          expect(subject.new(complex_field: ['1', '2']).complex_field).to eq(['1', '2'])
-        end
-
-        it "when the attributes's value is 1, should be converted to 1" do
-          expect(subject.new(complex_field: 1).complex_field).to eq(1)
-        end
-
-        it "when the attributes's value is { first_name: ['1', '2'] }, should be converted to { first_name: ['1', '2'] }" do
-          expect(subject.new(complex_field: { first_name: ['1', '2'] }).complex_field).to eq({ first_name: ['1', '2'] })
-        end
-
-        it "when the attributes's value is -1, should be converted to -1" do
-          expect(subject.new(complex_field: -1).complex_field).to eq(-1)
-        end
-
-        it "when the attributes's value is 0.35, should be converted to 0.35" do
-          expect(subject.new(complex_field: 0.35).complex_field).to eq(0.35)
-        end
-
-      end
-
       context "that is declared (in schema) as an integer" do
 
         it "when the attributes's value is '1', should be converted to 1" do
@@ -176,50 +113,6 @@ describe SmoothOperator::AttributeAssignment do
 
       end
 
-      context "that is declared (in schema) as an float" do
-
-        it "when the attributes's value is '1', should be converted to 1" do
-          expect(subject.new(price: '1').price).to eq(1.0)
-        end
-
-        it "when the attributes's value is '-1', should be converted to -1" do
-          expect(subject.new(price: '-1').price).to eq(-1.0)
-        end
-
-        it "when the attributes's value is 's-10s', should be converted to -10" do
-          expect(subject.new(price: 's-10s').price).to eq(-10.0)
-        end
-
-        it "when the attributes's value is ' 10s', should be converted to 10" do
-          expect(subject.new(price: ' 10s').price).to eq(10.0)
-        end
-
-        it "when the attributes's value is 123, should be converted to 123" do
-          expect(subject.new(price: 123).price).to eq(123.0)
-        end
-
-        it "when the attributes's value is -5, should be converted to -5" do
-          expect(subject.new(price: -5).price).to eq(-5.0)
-        end
-
-        it "when the attributes's value is '12.3', should be converted to 12.3" do
-          expect(subject.new(price: '12.3').price).to eq(12.3)
-        end
-
-        it "when the attributes's value is 's12.3s', should be converted to 12.3" do
-          expect(subject.new(price: 's12.3s').price).to eq(12.3)
-        end
-
-        it "when the attributes's value is 's12,3s', should be converted to 12.3" do
-          expect(subject.new(price: 's12,3s').price).to eq(12.3)
-        end
-
-        it "when the attributes's value is 1.2, should be converted to 1.2" do
-          expect(subject.new(price: 1.2).price).to eq(1.2)
-        end
-
-      end
-
       context "that is declared (in schema) as an boolean" do
 
         it "when the attributes's value is true, should be converted to true" do
@@ -237,7 +130,7 @@ describe SmoothOperator::AttributeAssignment do
         it "when the attributes's value is 'false', should be converted to false" do
           expect(subject.new(manager: 'false').manager).to be(false)
         end
-
+        
         it "when the attributes's value is '1', should be converted to true" do
           expect(subject.new(manager: '1').manager).to be(true)
         end
@@ -255,7 +148,7 @@ describe SmoothOperator::AttributeAssignment do
         end
 
       end
-
+      
       context "that is declared (in schema) as an existing class" do
 
         it "if the attribute's value is an hash a new instance of that class will be initialized with that hash" do
@@ -271,12 +164,12 @@ describe SmoothOperator::AttributeAssignment do
 
         it "if the attribute's value is an array, a new instance of that class will be initialized for each array entry" do
           posts = subject.new(posts: [{ body: 'post1' }, { body: 'post2' }]).posts
-
+          
           expect(posts.length).to be(2)
 
           expect(posts[0]).to be_instance_of(Post)
           expect(posts[0].body).to eq('post1')
-
+          
           expect(posts[1]).to be_instance_of(Post)
           expect(posts[1].body).to eq('post2')
         end
@@ -308,33 +201,6 @@ describe SmoothOperator::AttributeAssignment do
 
       end
 
-      context "that is declared (in schema) as a datetime" do
-
-        it "if the attribute's value is a valid datetime string" do
-          date = subject.new(date: '2-2-2222 12:30').date
-
-          expect(date).to be_instance_of(DateTime)
-          expect(date.day).to be(2)
-          expect(date.month).to be(2)
-          expect(date.year).to be(2222)
-          expect(date.hour).to be(12)
-          expect(date.min).to be(30)
-        end
-
-        it "if the attribute's value is a valid datetime" do
-          date_now = DateTime.now
-          date = subject.new(date: date_now).date
-
-          expect(date).to be_instance_of(DateTime)
-          expect(date).to eq(date_now)
-        end
-
-        it "if the attribute's value is an invalid datetime string, the returning value should be nil" do
-          expect(subject.new(date: '2s-2-2222').date).to be_nil
-        end
-
-      end
-
     end
 
   end

data/spec/smooth_operator/delegation_spec.rb

@@ -45,7 +45,7 @@ describe SmoothOperator::Delegation do
   describe "#method_missing" do
     
     context "when calling a method that matches the initialized attributes" do
-      subject { User::Base.new(attributes_for(:user)) }
+      subject { User.new(attributes_for(:user)) }
 
       it 'it should return the value of that same attribute' do
         attributes_for(:user).each do |key, value|
@@ -54,83 +54,80 @@ describe SmoothOperator::Delegation do
       end
     end
 
-    context "when .strict_behaviour is true" do
-      subject { UserWithAddressAndPosts::Son.new(attributes_for(:user_with_address_and_posts)) }
 
-      context "when calling a method that doesn't match the initialized attributes but matches the schema" do
-        it 'it should return nil' do
-          expect(subject.manager).to eq(nil)
-        end
+    subject { UserWithAddressAndPosts::Son.new(attributes_for(:user_with_address_and_posts)) }
 
-        it "#respond_to? must return true" do
-          expect(subject.respond_to?(:manager)).to eq(true)
-        end
+    context "when calling a method that doesn't match the initialized attributes but matches the schema" do
+      it 'it should return nil' do
+        expect(subject.manager).to eq(nil)
       end
+    end
 
-      context "when calling a method that doesn't match either the schema nor the initialized attributes" do
-        it 'it should raise NoMethodError' do
-          expect { subject.unknown_method }.to raise_error NoMethodError
-        end
+    context "when calling a method that doesn't match either the schema nor the initialized attributes" do
+      it 'it should raise NoMethodError' do
+        expect { subject.unknown_method }.to raise_error NoMethodError
+      end
+    end
 
-        it "#respond_to? must return false" do
-          expect(subject.respond_to?(:unknown_method)).to eq(false)
-        end
+    context "when setting a new attribute not declared on schema" do
+      before { subject.unknown_attribute = 'unknown_value' }
+
+      it "#known_attributes must reflect that new attribute" do
+        expect(subject.known_attributes.to_a).to include('unknown_attribute')
+      end
+      
+      it "#respond_to? must return true" do
+        expect(subject.respond_to?(:unknown_attribute)).to eq(true)
       end
+      
+      it "calling a method with the same name must return that attribute's value" do
+        expect(subject.unknown_attribute).to eq('unknown_value')
+      end
+    end
 
-      context "when setting a new attribute not declared on schema" do
-        before { subject.unknown_attribute = 'unknown_value' }
+    context "when no changes are made to an attribute" do
+      it "checking it that attribute is changed, should return false" do
+        expect(subject.first_name_changed?).to be false
+      end
 
-        it "#known_attributes must reflect that new attribute" do
-          expect(subject.known_attributes.to_a).to include('unknown_attribute')
-        end
-        
-        it "#respond_to? must return true" do
-          expect(subject.respond_to?(:unknown_attribute)).to eq(true)
-        end
-        
-        it "calling a method with the same name must return that attribute's value" do
-          expect(subject.unknown_attribute).to eq('unknown_value')
-        end
+      it "checking that attribute past value, should its original value" do
+        expect(subject.first_name_was).to eq('John')
       end
     end
 
-    context "when .strict_behaviour is false" do
-      subject { UserWithAddressAndPosts::SoftBehaviour.new(attributes_for(:user_with_address_and_posts)) }
+    context "when there are changes made to an attribute" do
+      before { subject.first_name = 'nhoJ' }
 
-      context "when calling a method that doesn't match the initialized attributes but matches the schema" do
-        it 'it should return nil' do
-          expect(subject.manager).to eq(nil)
-        end
+      it "checking if that attribute is changed, should return true" do
+        expect(subject.first_name_changed?).to be true
+      end
 
-        it "#respond_to? must return true" do
-          expect(subject.respond_to?(:manager)).to eq(true)
-        end
+      it "checking that attribute past value, should its original value" do
+        expect(subject.first_name_was).to eq('John')
       end
 
-      context "when calling a method that doesn't match either the schema nor the initialized attributes" do
-        it 'it should return nil' do
-          expect(subject.unknown_method).to eq(nil)
+      context "when there are changes to the changes made to an attribute" do
+        before { subject.first_name = 'no_name' }
+
+        it "checking it that attribute is changed, should return true" do
+          expect(subject.first_name_changed?).to be true
         end
 
-        it "#respond_to? must return false" do
-          expect(subject.respond_to?(:unknown_method)).to eq(false)
+        it "checking that attribute past value, should its first original value" do
+          expect(subject.first_name_was).to eq('John')
         end
       end
+    end
 
-      context "when setting a new attribute not declared on schema" do
-        before { subject.unknown_attribute = 'unknown_value' }
+    context "when there are changes made to a nested object" do
+      before { subject.address.street = 'my street' }
 
-        it "#known_attributes must reflect that new attribute" do
-          expect(subject.known_attributes.to_a).to include('unknown_attribute')
-        end
-        
-        it "#respond_to? must return true" do
-          expect(subject.respond_to?(:unknown_attribute)).to eq(true)
-        end
-        
-        it "calling a method with the same name must return that attribute's value" do
-          expect(subject.unknown_attribute).to eq('unknown_value')
-        end
+      it "checking if the nested object as changed, should return false" do
+        expect(subject.address_changed?).to be false
+      end
+
+      it "checking if the nested object's attribute as changed, should return true" do
+        expect(subject.address.street_changed?).to be true
       end
     end
 

data/spec/smooth_operator/finder_methods_spec.rb

@@ -1,100 +1,11 @@
 require "spec_helper"
 
-shared_examples_for "finder method" do
-  it "it should return a RemoteCall instance with a subject's class instance" do
-    expect(user).to be_instance_of(subject)
-  end
-
-  it "the instance class should be populated with the returned hash" do
-    expect(user.attributes).to eq(attributes_for(:user_with_address_and_posts))
-  end
-end
-
 describe SmoothOperator::FinderMethods do
-  subject { UserWithAddressAndPosts::Son }
-
-  # describe ".all" do
-  #   context "when NO arguments are passed" do
-  #     it "it should can .find(:all, {}, {})" do
-  #       expect(subject).to receive(:find).with(:all, {}, {})
-  #       subject.all
-  #     end
-  #   end
+  subject { User }
 
-  #   context "when arguments are passed" do
-  #     it "it should can .find(:all) with the same arguments that .alll has received" do
-  #       arguments = [{ id: 2 }, { http_verb: 'head' }]
-
-  #       expect(subject).to receive(:find).with(:all, *arguments)
-
-  #       subject.all(*arguments)
-  #     end
-  #   end
-  # end
 
   describe ".find" do
-    context "when the server returns a single hash" do
-      let(:user) { subject.find(5).data }
-
-      it_behaves_like "finder method"
-    end
-
-    context "when the server returns a hash with meta_data" do
-      let(:user) { subject.find("5/with_metadata").data }
-
-      it_behaves_like "finder method"
-
-      it "#meta_data should reflect the receiving meta_data" do
-        expect(user._meta_data).to eq({ "status" => 1 })
-      end
-
-      it "user should NOT contain meta_data" do
-        expect { user.status }.to raise_error NoMethodError
-      end
-    end
-
-    context "when the server returns an array" do
-      it "it should return a RemoteCall instance an array that contains a subject's class instance, one for every array's entry" do
-        remote_call = subject.find(:all)
-        users = remote_call.data
-
-        expect(users).to be_instance_of(Array)
-        expect(users[0]).to be_instance_of(subject)
-        expect(users[1]).to be_instance_of(subject)
-      end
-
-      it "if any of the array entries is not a hash, it shall not be converted or alteread" do
-        remote_call = subject.find('misc_array')
-        users = remote_call.data
-
-        expect(users).to be_instance_of(Array)
-        expect(users[0]).to be_instance_of(subject)
-        expect(users[1]).to be(2)
-      end
-    end
-
-    context "when the server returns a hash with a key (equal to subject's call.resources_name) containing an array" do
-      it "it should return a RemoteCall instance an instance of ArrayWithMetaData" do
-        remote_call = subject.find('with_metadata')
-        users = remote_call.data
-
-        expect(users).to be_instance_of(SmoothOperator::ArrayWithMetaData)
-        expect(users.page).to be(1)
-        expect(users.total).to be(6)
-        users.each { |user| expect(user).to be_instance_of(subject) }
-      end
-    end
-
-    context "when the server returns an array with nested object on each entry, with the same name has the resource" do
-      it "it should return an Array with Class instances" do
-        remote_call = subject.find('array_with_nested_users')
-        users = remote_call.data
-
-        expect(users).to be_instance_of(Array)
-        users.each { |user| expect(user).to be_instance_of(subject) }
-      end
-    end
-
+    
   end
 
 end