bintje 0.4.0

data/lib/xmlrpc/parser_patch.rb

@@ -0,0 +1,50 @@
+##
+#
+# Bintje Maps OpenERP xml object to Ruby objects
+#
+#    Copyright (C) 2013  Siclic
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as
+#    published by the Free Software Foundation, either version 3 of the
+#    License, or (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##
+
+
+module XMLRPC
+  module Convert
+
+    # Converts the given +hash+ to an XMLRPC::FaultException object by passing
+    # the +faultCode+ and +faultString+ attributes of the Hash to
+    # XMLRPC::FaultException.new
+    #
+    # Raises an Exception if the given +hash+ doesn't meet the requirements.
+    # Those requirements being:
+    # * 2 keys
+    # * <code>'faultCode'</code> key is an Integer
+    # * <code>'faultString'</code> key is a String
+    # 
+    # @param hash [Hash] the fault exception
+    # @return [XMLRPC:FaultException] the better exception 
+    def self.fault(hash)
+      if hash.kind_of? Hash and hash.size == 2 and
+          hash.has_key? "faultCode" and hash.has_key? "faultString" and
+          hash["faultCode"].kind_of? Integer or hash["faultCode"].kind_of? String and hash["faultString"].kind_of? String
+
+        XMLRPC::FaultException.new(hash["faultCode"], hash["faultString"])
+      else
+        raise "wrong fault-structure: #{hash.inspect}"
+      end
+    end
+
+  end
+end

data/license_header.txt

@@ -0,0 +1,22 @@
+##
+#
+# Bintje Maps OpenERP xml object to Ruby objects
+#
+#    Copyright (C) 2013  Siclic
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as
+#    published by the Free Software Foundation, either version 3 of the
+#    License, or (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##
+
+

data/spec/data/faultCode.txt

@@ -0,0 +1 @@
+warning -- Erreur d'accès Opération interdite par les règles d'accès, ou effectué sur un document déjà supprimé (Opération : lecture, Type de document: openstc.ask).

data/spec/data/faultString.txt

@@ -0,0 +1,5 @@
+XMLRPC::FaultException ():
+app/controllers/openstc/api/intervention_requests_controller.rb:19:in `update'
+Rendered /home/cedric/.rvm/gems/ruby-2.0.0-p195@barakafrites/gems/actionpack-3.2.13/lib/action_dispatch/middleware/templates/rescues/_trace.erb (1.0ms)
+Rendered /home/cedric/.rvm/gems/ruby-2.0.0-p195@barakafrites/gems/actionpack-3.2.13/lib/action_dispatch/middleware/templates/rescues/_request_and_response.erb (0.6ms)
+Rendered /home/cedric/.rvm/gems/ruby-2.0.0-p195@barakafrites/gems/actionpack-3.2.13/lib/action_dispatch/middleware/templates/rescues/diagnostics.erb within rescues/layout (30.2ms)

data/spec/openerp_common_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'request_shared_examples'
+
+describe "OpenObject" do
+
+  context 'for common context' do
+
+    before :each do
+      open_object_settings
+    end
+
+    describe '.common_client' do
+      it 'build new XMLRPC connection client Proxy' do
+        allow_message_expectations_on_nil
+        XMLRPC::Client.should_receive(:new)
+        .with('localhost', '/xmlrpc/common', '8069')
+        .and_return().should_receive(:proxy).with(nil)
+        OpenObject.common_client
+      end
+    end
+
+    describe '.login' do
+
+      context 'with wrong database name' do
+        before(:each) do
+          ServerStub::Common::Login.wrong_data_base_name
+        end
+        let(:response) { OpenObject.login('dbname', 'user', 'password') }
+
+        it "response.success : false" do
+          response.success.should be false
+        end
+
+        it " response.errors : #{ServerStub::Common::Login.wrong_database_name_fault_code}" do
+          response.errors[:faultCode].should include(ServerStub::Common::Login.wrong_database_name_fault_code)
+        end
+
+      end
+
+      context 'with wrong user name and/or password' do
+        before(:each) do
+          ServerStub::Common::Login.wrong_user_name
+        end
+        let(:response) { OpenObject.login('dbname', 'user', 'password') }
+
+        it "response.success : false" do
+          response.success.should be false
+        end
+
+      end
+
+
+      context 'on successful authentication request' do
+        before(:each) do
+          ServerStub::Common::Login.successful
+        end
+        let(:response) { OpenObject.login('dbname', 'user', 'password') }
+
+        it_behaves_like 'any successful request'
+
+        it "response.content.class = Fixnum (user id)" do
+          response.content.class.should be Fixnum
+        end
+
+        it "response.content == #{ServerStub::Common::Login.uid} (expected user id)" do
+          response.content.should be ServerStub::Common::Login.uid
+        end
+
+      end
+
+
+    end
+
+  end
+
+
+end

data/spec/reciever_model_spec.rb

@@ -0,0 +1,270 @@
+require 'spec_helper'
+
+describe 'reciever model' do
+  before(:each) do
+    open_object_settings
+  end
+  let(:user_context) { {dbname: 'dbname', uid: 2, pwd: 'pwd'} }
+
+  class ReceiverModel
+    include OpenObject
+  end
+
+  it 'should respond to .open_object_model' do
+    ReceiverModel.should respond_to(:open_object_model)
+  end
+
+
+  describe '.open_object_model_name' do
+    context 'when not defined in model' do
+
+      it 'should be a string' do
+        ReceiverModel.open_object_model.class.should be String
+      end
+
+      it 'should be humanized model name' do
+        ReceiverModel.open_object_model.should eql 'receiver_model'
+      end
+
+    end
+
+    describe ".set_open_object_mode('another_name')" do
+      class AnotherModel
+        include OpenObject
+      end
+      it "should set the open_object model name with the given string" do
+        AnotherModel.set_open_object_model "another_name"
+        AnotherModel.open_object_model.should eql "another_name"
+      end
+
+    end
+
+  end
+
+  describe ".connection(user_context:{dbname:String,uid:Fixnum,pwd:String})" do
+
+
+    it "should build a new XMLRPC connection" do
+      allow_message_expectations_on_nil
+      XMLRPC::Client.should_receive(:new)
+      .with(OpenObject.host, OpenObject.object, OpenObject.port)
+      .and_return().should_receive(:proxy)
+      ReceiverModel.connection(user_context)
+    end
+
+
+  end
+
+  describe ".search(user_context, args = [], limit:Fixnum, offset:Fixnum)" do
+    before(:each) do
+      allow_message_expectations_on_nil
+      ServerStub::Object::Search.prologue
+    end
+
+    let(:response) { ReceiverModel.search(user_context, [["field", "operator", "value"]]) }
+
+
+    context "with offset and limit parameters" do
+      let(:response) { ReceiverModel.search(user_context, [["field", "operator", "value"]],offset: 10,limit: 5) }
+
+      it "invokes execute with model_name, search, [params], offset,limit" do
+        ServerStub::Object::Connection.prologue.should_receive(:execute)
+        .with('receiver_model','search',[["field", "operator", "value"]], 10 , 5 )
+        response
+      end
+
+    end
+
+    context "with limit parameter (missing offset)" do
+      let(:response) { ReceiverModel.search(user_context, [["field", "operator", "value"]],limit: 5) }
+
+      it "invokes execute with model_name, search, [params], offset :0, limit " do
+        ServerStub::Object::Connection.prologue.should_receive(:execute)
+        .with('receiver_model','search',[["field", "operator", "value"]], 0 , 5 )
+        response
+      end
+
+    end
+
+    context "with offset parameter (missing limit)" do
+      let(:response) { ReceiverModel.search(user_context, [["field", "operator", "value"]], offset: 10) }
+
+      it "invokes execute with model_name, search, [params], offset, limit: 0" do
+        ServerStub::Object::Connection.prologue.should_receive(:execute)
+        .with('receiver_model','search',[["field", "operator", "value"]], 10 , 0 )
+        response
+      end
+
+    end
+
+    context "without limit and offset" do
+
+      it_behaves_like "any object request"
+
+      it "invokes execute with model_name, search, [params], 0, 0" do
+        ServerStub::Object::Connection.prologue.should_receive(:execute)
+        .with('receiver_model','search',[["field", "operator", "value"]], 0,0)
+        response
+
+      end
+    end
+
+
+    context "with order parameter" do
+      let(:response) { ReceiverModel.search(user_context, [["field", "operator", "value"]], order: 'name DESC') }
+
+      it "invokes execute with model_name, search, [params], 0, 0, order" do
+        ServerStub::Object::Connection.prologue.should_receive(:execute)
+        .with('receiver_model','search',[["field", "operator", "value"]], 0,0, 'name DESC')
+        response
+      end
+
+    end
+
+    context "successful request" do
+      before(:each) { ServerStub::Object::Search.successful }
+      let(:response) { ReceiverModel.search(user_context, [["field", "operator", "value"]]) }
+
+      it_behaves_like "any successful request"
+
+      it "response.content should be an Array" do
+        response.content.should be_an Array
+      end
+
+    end
+
+    context "failed request" do
+      before(:each) do
+        ServerStub::Object::Search.failure
+      end
+
+      it_behaves_like "any failed request"
+
+    end
+
+  end
+
+  describe ".read(user_context,[ids],[fields])" do
+    before(:each) do
+      allow_message_expectations_on_nil
+      ServerStub::Object::Read.prologue
+    end
+
+    let(:response) {ReceiverModel.read(user_context,[1,2],['fields']) }
+
+    it_behaves_like "any object request"
+
+    it "invokes execute with model_name, read, [ids], [fields]" do
+      ServerStub::Object::Connection.prologue.should_receive(:execute)
+      .with('receiver_model','read',[1,2],['fields'])
+      response
+    end
+
+    context "successful request" do
+      before(:each) do
+        ServerStub::Object::Read.successful
+      end
+
+      it_behaves_like "any successful request"
+
+      it "response.content should be Array" do
+        response.content.should be_an Array
+      end
+
+      it "reponse.content.first should be #{ServerStub::Object::Read.standard_response.first}" do
+        response.content.first.should eql ServerStub::Object::Read.standard_response.first
+      end
+
+    end
+
+    context "failed request" do
+      before(:each) do
+        ServerStub::Object::Read.failure
+      end
+
+      it_behaves_like "any failed request"
+
+    end
+
+  end
+
+  describe ".write(user_context,[ids],{field:'value'})" do
+    before(:each) do
+      allow_message_expectations_on_nil
+      ServerStub::Object::Write.prologue
+    end
+    let(:response) { ReceiverModel.write(user_context, [1,2],{field:'value'})}
+
+    it_behaves_like "any object request"
+
+    it "invokes execute with model_name, 'write', [ids], {field:'value'}" do
+      ServerStub::Object::Connection.prologue.should_receive(:execute)
+      .with('receiver_model', 'write', [1,2], {field:'value'})
+      response
+    end
+
+    context "successful request" do
+      before(:each) do
+        ServerStub::Object::Write.successful
+      end
+
+      it_behaves_like "any successful request"
+
+      it "response.content should be nil" do
+        response.content.should be nil
+      end
+
+    end
+
+    context "failed request" do
+      before(:each) do
+        ServerStub::Object::Write.failure
+      end
+
+      it_behaves_like "any failed request"
+
+    end
+
+  end
+
+  describe ".create(user_context,{field:value})" do
+    before(:each) do
+      allow_message_expectations_on_nil
+      ServerStub::Object::Create.prologue
+    end
+
+    let(:response) { ReceiverModel.create(user_context,{field:'value'})}
+
+    it_behaves_like "any object request"
+
+    it "invokes execute with model_name, 'create', {field:'value'}" do
+      ServerStub::Object::Connection.prologue.should_receive(:execute)
+      .with('receiver_model', 'create', {field:'value'})
+      response
+    end
+
+    context "successful request" do
+      before(:each) do
+        ServerStub::Object::Create.successful
+      end
+
+      it_behaves_like "any successful request"
+
+      it "reponse.content should be 1" do
+        response.content.should be 1
+      end
+
+    end
+
+    context "failed request" do
+      before(:each) do
+        ServerStub::Object::Create.failure
+      end
+
+      it_behaves_like "any failed request"
+
+    end
+
+  end
+
+end

data/spec/request_shared_examples.rb

@@ -0,0 +1,42 @@
+module RequestSharedExamples
+
+
+    shared_examples_for "any request" do
+      it "response.class == OpenObject::BackendResponse" do
+        response.class.should be OpenObject::BackendResponse
+      end
+    end
+
+    shared_examples_for "any successful request" do
+      it_behaves_like "any request"
+      it "response.success : true" do
+        response.success.should be true
+      end
+    end
+
+    shared_examples_for "any failed request" do
+      it_behaves_like "any request"
+      it "response.success : false" do
+        response.success.should be false
+      end
+
+      it "response.errors[:faultCode] Server faultCode" do
+        response.errors[:faultCode].should eql ServerStub.faultCode
+      end
+
+      it "response.errors[:faultString] Server faultString" do
+        response.errors[:faultString].should eql ServerStub.faultString
+      end
+
+    end
+
+
+    shared_examples_for "any object request" do
+      it "creates connection with context" do
+        ReceiverModel.should_receive(:connection).with(user_context)
+        response
+      end
+    end
+
+
+end