smooth_operator 0.4.4 → 1.2.0

data/spec/smooth_operator/delegation_spec.rb

@@ -0,0 +1,139 @@
+require "spec_helper"
+
+describe SmoothOperator::Delegation do
+
+  describe "#respond_to?" do
+    let(:initial_attributes_keys) { attributes_for(:user_with_address_and_posts).keys }
+
+    context "when there is no declared schema" do
+      subject { UserWithAddressAndPosts::UserWithMyMethod.new(attributes_for(:user_with_address_and_posts)) }
+
+      it 'it should return true for every attribute used uppon initialization' do
+        initial_attributes_keys.each do |attribute|
+          expect(subject.respond_to?(attribute)).to eq(true)
+        end
+      end
+
+      it 'it should return false in for unknown attributes/methods' do
+        expect(subject.respond_to?(:unknown)).to eq(false)
+      end
+
+      it 'it should return true for any existing method' do
+        expect(subject.respond_to?(:my_method)).to eq(true)
+      end
+    end
+
+    context "when there is a known schema" do
+      subject { UserWithAddressAndPosts::Son.new(attributes_for(:user_with_address_and_posts)) }
+      let(:known_schema_attributes) { ["posts", "address", "manager"] }
+
+      it 'it should return true for every attribute used uppon initialization' do
+        initial_attributes_keys.each do |attribute|
+          expect(subject.respond_to?(attribute)).to eq(true)
+        end
+      end
+
+      it 'it should return true for known schema attributes' do
+        known_schema_attributes.each do |attribute|
+          expect(subject.respond_to?(attribute)).to eq(true)
+        end
+      end
+    end
+
+  end
+
+  describe "#method_missing" do
+    
+    context "when calling a method that matches the initialized attributes" do
+      subject { User::Base.new(attributes_for(:user)) }
+
+      it 'it should return the value of that same attribute' do
+        attributes_for(:user).each do |key, value|
+          expect(subject.send(key)).to eq(value)
+        end
+      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
+
+        it "#respond_to? must return true" do
+          expect(subject.respond_to?(:manager)).to eq(true)
+        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
+
+        it "#respond_to? must return false" do
+          expect(subject.respond_to?(:unknown_method)).to eq(false)
+        end
+      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
+    end
+
+    context "when .strict_behaviour is false" do
+      subject { UserWithAddressAndPosts::SoftBehaviour.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
+
+        it "#respond_to? must return true" do
+          expect(subject.respond_to?(:manager)).to eq(true)
+        end
+      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)
+        end
+
+        it "#respond_to? must return false" do
+          expect(subject.respond_to?(:unknown_method)).to eq(false)
+        end
+      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
+    end
+
+  end
+
+end

data/spec/smooth_operator/finder_methods_spec.rb

@@ -0,0 +1,105 @@
+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
+
+  it "#has_data_from_server and #from_server should return true" do
+    expect(user.has_data_from_server).to be true
+    expect(user.from_server).to be true
+  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
+
+  #   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).object }
+
+      it_behaves_like "finder method"
+    end
+
+    context "when the server returns a hash with meta_data" do
+      let(:user) { subject.find("5/with_metadata").object }
+
+      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.objects
+
+        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.objects
+
+        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

data/spec/smooth_operator/model_schema_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe SmoothOperator::ModelSchema do
+
+  describe "#known_attributes" do
+    let(:initial_attributes_keys) { attributes_for(:user).keys.map(&:to_s) }
+
+    context "when there is no declared schema" do
+      subject { User::Base.new(attributes_for(:user)) }
+
+      it 'it should reflect the attributes used uppon initialization' do
+        expect(subject.known_attributes.to_a).to match_array(initial_attributes_keys)
+      end
+    end
+
+    context "when there is a known schema" do
+      subject { UserWithAddressAndPosts::Son.new(attributes_for(:user)) }
+      let(:known_schema_attributes) { ["posts", "address", "manager"] }
+
+      it 'it should reflect the attributes used uppon initialization' do
+        expect(subject.known_attributes.to_a).to include(*initial_attributes_keys)
+      end
+
+      it 'it should reflect the known schema attributes' do
+        expect(subject.known_attributes.to_a).to include(*known_schema_attributes)
+      end
+    end
+
+  end
+
+end

data/spec/smooth_operator/operator_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe SmoothOperator::Operator do
+  subject { User::Base }
+
+  describe "#get" do
+
+    context "submiting a hash, with an array" do
+
+      it 'should correctly encode that hash' do
+        remote_call = subject.get('test_hash_with_array', attributes_for(:user_with_address_and_posts))
+        
+        expect(remote_call.status).to eq(true)
+      end
+
+    end
+
+    it "should send the extra params set by .query_string method" do
+      remote_call = subject.get('test_query_string', { normal_param: true })
+
+      expect(remote_call.status).to eq(true)
+    end
+
+  end
+
+  describe "#post" do
+
+    context "submiting a hash, with an array" do
+
+      it 'should correctly encode that hash' do
+        remote_call = subject.post('test_hash_with_array', attributes_for(:user_with_address_and_posts))
+
+        expect(remote_call.status).to eq(true)
+      end
+
+    end
+
+    it "should send the extra params set by .query_string method" do
+      remote_call = subject.post('test_query_string', { normal_param: true })
+
+      expect(remote_call.status).to eq(true)
+    end
+
+  end
+
+end