ecircle_soap_client 0.0.5

data/test/test_ecircle_soap_client.rb

@@ -0,0 +1,317 @@
+require File.dirname(__FILE__)+'/helper'
+require 'ostruct'
+
+class TestEcircleSoapClient < Test::Unit::TestCase
+
+  def setup
+    config_soap_client
+  end
+
+  context "time helpers" do
+    should "extend Time with ecircle_format" do
+      assert_equal({ :snafu_yyyy => '1910',
+                     :snafu_mm   => '00',
+                     :snafu_dd   => '01',
+                     :snafu_hh   => '04',
+                     :snafu_min  => '03',
+                     :snafu_ss   => '09',
+                   }, Time.mktime(1910, 1, 1, 4, 3, 9).ecircle_format("snafu"))
+    end
+
+    should "extend Date with ecircle_format" do
+      assert_equal({ :fubar_yyyy => '1910',
+                     :fubar_mm   => '00',
+                     :fubar_dd   => '01',
+                     :fubar_hh   => '00',
+                     :fubar_min  => '00',
+                     :fubar_ss   => '00',
+                   }, Date.new(1910, 1, 1).ecircle_format("fubar"))
+    end
+  end
+
+  context "Ecircle::Client.attempt" do
+    setup do
+      @yield_count = 0
+    end
+
+    should "yield once if all goes well" do
+      assert_difference "@yield_count", 1 do
+        Ecircle::Client.attempt do
+          @yield_count += 1
+        end
+      end
+    end
+
+    should "raise exception if anything other than is raised" do
+      assert_difference "@yield_count", 1 do
+        assert_raises RuntimeError do
+          Ecircle::Client.attempt do
+            @yield_count += 1
+            raise RuntimeError, "fubar"
+          end
+        end
+      end
+    end
+
+    should "default should be 2 retries" do
+      # 3 because the '+= 1' happens before the exception is thrown.
+      assert_difference "@yield_count", 3 do
+        assert_raises Ecircle::Client::NotLoggedIn do
+          Ecircle::Client.attempt do
+            @yield_count += 1
+            raise Ecircle::Client::NotLoggedIn.new
+          end
+        end
+      end
+    end
+
+    should "should retry on NoMethodError but only for findMembershipByEmail" do
+      # 3 because the '+= 1' happens before the exception is thrown.
+      assert_difference "@yield_count", 1 do
+        assert_raises NoMethodError do
+          Ecircle::Client.attempt do
+            @yield_count += 1
+            raise NoMethodError, "funar"
+          end
+        end
+      end
+
+      assert_difference "@yield_count", 3 do
+        assert_raises NoMethodError do
+          Ecircle::Client.attempt do
+            @yield_count += 1
+            raise NoMethodError, "No such operation 'FindMembershipsByEmail'"
+          end
+        end
+      end
+
+      assert_difference "@yield_count", 11 do
+        assert_raises NoMethodError do
+          Ecircle::Client.attempt(10) do
+            @yield_count += 1
+            raise NoMethodError, "No such operation 'FindMembershipsByEmail'"
+          end
+        end
+      end
+    end
+
+    should "retry if one of two errors is thrown - propogate error on final retry" do
+      clnobj = Object.new
+      mock(clnobj).logon.times(2) { "" }
+      mock(Ecircle).client.any_number_of_times { clnobj }
+
+      assert_difference "@yield_count", 6 do
+        assert_raises Ecircle::Client::PermissionDenied do
+          Ecircle::Client.attempt(retries = 5) do
+            @yield_count += 1
+            raise Ecircle::Client::NotLoggedIn.new, "fubar" if @yield_count % 2 == 1
+            raise Ecircle::Client::PermissionDenied.new , "fubar" if @yield_count % 2 == 0
+          end
+        end
+      end
+    end
+
+    should "stop retries if no exception is raised - notloggedin" do
+      assert_difference "@yield_count", 5 do
+        Ecircle::Client.attempt(retries = 5) do
+          @yield_count += 1
+          raise Ecircle::Client::NotLoggedIn.new, "fubar" if @yield_count < 5
+        end
+      end
+    end
+
+    should "stop retries if no exception is raised - permission denied" do
+      clnobj = Object.new
+      mock(clnobj).logon.times(4) { "" }
+      mock(Ecircle).client.any_number_of_times { clnobj }
+
+      assert_difference "@yield_count", 5 do
+        Ecircle::Client.attempt(retries = 5) do
+          @yield_count += 1
+          raise Ecircle::Client::PermissionDenied.new, "fubar" if @yield_count < 5
+        end
+      end
+    end
+
+    should "exit immediately if the logon method raises exception" do
+      clnobj = Object.new
+      mock(clnobj).logon do
+        raise Ecircle::Client::PermissionDenied.new, "came from login"
+      end
+      mock(Ecircle).client.any_number_of_times { clnobj }
+
+      exp = nil
+      assert_difference "@yield_count", 1 do
+        exp = assert_raises Ecircle::Client::PermissionDenied do
+          Ecircle::Client.attempt(retries = 5) do
+            @yield_count += 1
+            raise Ecircle::Client::PermissionDenied.new, "fubar" if @yield_count < 5
+          end
+        end
+      end
+      assert_equal "came from login", exp.message
+    end
+
+    should "don't call logon when not loggedin exception is raised" do
+      mock(Ecircle).client.times(0)
+
+      assert_difference "@yield_count", 3 do
+        Ecircle::Client.attempt(retries = 10) do
+          @yield_count += 1
+          raise Ecircle::Client::NotLoggedIn.new, "fubar" if @yield_count < 3
+        end
+      end
+    end
+  end
+
+
+  context "Ecircle::Client" do
+    should "logon if not logged in" do
+      mock_ecircle_client(true) do |client, req_obj|
+        req_obj.request("FuBaR") { raise _soap_fault("No such operation: fu_ba_r") }
+        mock(client).logon { nil }
+
+        assert_raises NoMethodError do
+          client.method_missing(:fu_ba_r, nil)
+        end
+      end
+    end
+
+    should "throw not logged in exception" do
+      mock_ecircle_client(true) do |client, req_obj|
+        req_obj.request("FuBaR") { raise _soap_fault("Not authenticated: stupid me") }
+        mock(client).logon { nil }
+
+        assert_raises Ecircle::Client::NotLoggedIn do
+          client.method_missing(:fu_ba_r, nil)
+        end
+      end
+    end
+
+    should "propagate unknown exception up" do
+      mock_ecircle_client(true) do |client, req_obj|
+        req_obj.request("FuBaR") { raise _soap_fault("Not a valid email") }
+        mock(client).logon { nil }
+
+        assert_raises Savon::SOAP::Fault do
+          client.method_missing(:fu_ba_r, nil)
+        end
+      end
+    end
+
+    should "be able to handle various exceptions" do
+      client = Ecircle::Client.new
+
+      assert_raises Savon::SOAP::Fault do
+        client.send( :handle_savon_fault, _soap_fault("Unknown exception message"),
+                     :for_method => 'fubar')
+      end
+
+      assert_raises RuntimeError do
+        client.send( :handle_savon_fault, RuntimeError.new("hello world"),
+                     :for_method => 'fubar')
+      end
+
+      begin
+        client.send( :handle_savon_fault, _soap_fault("No such operation"),
+                     :for_method => 'fubar')
+        assert false, "should not get here."
+      rescue NoMethodError => e
+        assert_equal "fubar (by way of (client) No such operation)", e.message
+      end
+
+      begin
+        client.send( :handle_savon_fault, _soap_fault("No such operation"))
+        assert false, "should not get here."
+      rescue NoMethodError => e
+        assert_equal "UNKNOWN (by way of (client) No such operation)", e.message
+      end
+
+      assert_raises Ecircle::Client::NotLoggedIn do
+        client.send( :handle_savon_fault, _soap_fault("Not authenticated"))
+      end
+      assert_raises Ecircle::Client::NotLoggedIn do
+        client.send( :handle_savon_fault, _soap_fault("LoginException"))
+      end
+
+      assert_raises Ecircle::Client::PermissionDenied do
+        client.send( :handle_savon_fault, _soap_fault("Authorisation failure"))
+      end
+      assert_raises Ecircle::Client::PermissionDenied do
+        client.send( :handle_savon_fault, _soap_fault("Permission Problem"))
+      end
+    end
+
+    should "not logon if already logged in" do
+      client, req_obj = Ecircle::Client.new, Object.new
+
+      mock(req_obj).request(:logon) do
+        OpenStruct.
+          new({:body => { :logon_response => { :logon_return => "somesessiontoken" }}})
+      end
+      mock(req_obj).request("Logon") do
+        OpenStruct.
+          new({:body => { :logon_response => { :logon_return => "somesessiontoken" }}})
+      end
+      mock(client).client.times(2) { req_obj }
+
+      client.logon
+      assert_equal "somesessiontoken", client.session_token
+
+      # now the session token is set, the logon method should not be called again.
+      mock(client).logon.times(0)
+      assert_equal "somesessiontoken", client.method_missing(:logon, nil)
+    end
+
+    context "parsing results" do
+
+      should "return nil for responses without content except attributes" do
+        mock_response(in_soap_body do
+          <<-SOAP
+            <FoobarResponse xmlns="">
+              <ns1:FoobarReturn xsi:nil="true" xmlns:ns1="http://webservices.ecircleag.com/rpcns"/>
+            </FoobarResponse>
+          SOAP
+        end)
+        assert_equal(nil, Ecircle.client.foobar)
+      end
+
+      should "return nil for responses without fitting content" do
+        mock_response(in_soap_body do
+          <<-SOAP
+            <FoobarResponse xmlns=""/>
+          SOAP
+        end)
+        assert_equal(nil, Ecircle.client.foobar)
+      end
+
+      [true, false].each do |boolean|
+        should "return #{boolean} for return value of #{boolean}" do
+          mock_response(in_soap_body do
+            <<-SOAP
+              <FoobarResponse xmlns="">
+                <ns1:FoobarReturn xsi:nil="true" xmlns:ns1="http://webservices.ecircleag.com/rpcns">
+                  #{boolean}
+                </ns1:FoobarReturn>
+              </FoobarResponse>
+            SOAP
+          end)
+          assert_equal(boolean, Ecircle.client.foobar)
+        end
+      end
+
+      should "return XML for responses with other content" do
+        mock_response(in_soap_body do
+          <<-SOAP
+            <FoobarResponse xmlns="">
+              <ns1:FoobarReturn xsi:nil="true" xmlns:ns1="http://webservices.ecircleag.com/rpcns">
+                Snafu
+              </ns1:FoobarReturn>
+            </FoobarResponse>
+          SOAP
+        end)
+        assert_equal("Snafu", Ecircle.client.foobar.strip)
+      end
+    end
+  end
+end

data/test/test_ecircle_soap_client_group.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__)+'/helper'
+require 'ostruct'
+
+class TestEcircleSoapClientGroup < Test::Unit::TestCase
+
+  def setup
+    config_soap_client
+
+    @example_user_string = Savon::SOAP::XML.new.xml do |x|
+      x.user(:id => "4130268167") do |u|
+        u.email("bill@microsoft.com")
+        u.title("-1")
+        u.firstname("Bill")
+        u.lastname("Gates")
+        u.nickname("")
+        u.dob_dd("")
+        u.dob_mm("")
+        u.dob_yyyy("")
+        u.countrycode("US")
+        u.languagecode("en")
+        9.times do |idx|
+          u.instance_eval "cust_attr_#{idx+1}('')"
+        end
+      end
+    end
+
+    @example_member_string = Savon::SOAP::XML.new.xml do |x|
+      x.member(:id => "4130268167g400123451") do |u|
+        u.email("me@you.com")
+      end
+    end
+  end
+
+  context "Ecircle::Group" do
+    should "have a remove_user method - part 1" do
+      grp, user = Ecircle::Group.new, Ecircle::User.new
+      mock(user).leave_group( grp, false) { "fubar" }
+      assert_equal "fubar", grp.remove_user(user)
+    end
+
+    should "have a remove_user method - part 2" do
+      grp, user = Ecircle::Group.new, Ecircle::User.new
+      mock(user).leave_group( grp, true) { "fubar" }
+      assert_equal "fubar", grp.remove_user(user, true)
+    end
+
+    should "have a remove member method - part 1" do
+      grp, usr, member = Ecircle::Group.new, Ecircle::User.new, Object.new
+      mock(usr).leave_group(grp, true) { "fubar" }
+      mock(member).user { usr }
+      assert_equal "fubar", grp.remove_member(member, true)
+    end
+
+    should "have a remove member method - part 2" do
+      grp, usr, member = Ecircle::Group.new, Ecircle::User.new, Object.new
+      mock(usr).leave_group(grp, false) { "fubar" }
+      mock(member).user { usr }
+      assert_equal "fubar", grp.remove_member(member)
+    end
+  end
+end

data/test/test_ecircle_soap_client_member.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__)+'/helper'
+require 'ostruct'
+
+class TestEcircleSoapClientMember < Test::Unit::TestCase
+
+  def setup
+    config_soap_client
+
+    @example_member_string = Savon::SOAP::XML.new.xml do |x|
+      x.member(:id => "4130268167g400123451") do |u|
+        u.email("me@you.com")
+      end
+    end
+  end
+
+  context "Ecircle::Member" do
+    should "have group id and user id from id" do
+      m = Ecircle::Member.new(@example_member_string)
+      assert_equal "4130268167", m.user_id
+      assert_equal "400123451", m.group_id
+    end
+
+    should "be able to get the group for a member" do
+      mock(Ecircle::Group).find_by_id("400123451") { "hi there" }
+      assert_equal "hi there", Ecircle::Member.new(@example_member_string).group
+    end
+
+    should "be able to get the user for a member" do
+      mock(Ecircle::User).find_by_id("4130268167") { "hi there" }
+      assert_equal "hi there", Ecircle::Member.new(@example_member_string).user
+    end
+
+    should "be able delete a member" do
+      mock_ecircle_client do |client|
+        client.delete_member(:memberId => "4130268167g400123451") { "he there" }
+        assert_equal "he there", Ecircle::Member.new(@example_member_string).delete
+      end
+    end
+
+    should "be able to find a member by id" do
+      mock_ecircle_client do |client|
+        member_id = "thisisthememnberid"
+        client.lookup_member_by_id(:memberid => member_id) { "he there" }
+        assert_equal "he there", Ecircle::Member.find_by_id(member_id)
+      end
+    end
+  end
+end

data/test/test_ecircle_soap_client_message.rb

@@ -0,0 +1,174 @@
+require File.dirname(__FILE__)+'/helper'
+require 'ostruct'
+
+class TestEcircleSoapClientMessage < Test::Unit::TestCase
+
+  def setup
+    config_soap_client
+  end
+
+  context "Ecircle::Message" do
+    should "have all class method" do
+      mock(Ecircle::Message).find_all_by_group_name("") { "hi there" }
+      assert_equal "hi there", Ecircle::Message.all
+    end
+
+    should "find_all_by_group_name - empty array if returned value is no array" do
+      mock_ecircle_client do |client|
+        client.lookup_messages(:lookupParams => { :groupName => "group name" }) { "ban" }
+        assert_equal [], Ecircle::Message.find_all_by_group_name("group name")
+      end
+    end
+
+    should "find_all_by_group_name - empty array if empty" do
+      mock_ecircle_client do |client|
+        client.lookup_messages(:lookupParams => { :groupName => "group name" }) { [] }
+        assert_equal [], Ecircle::Message.find_all_by_group_name("group name")
+      end
+    end
+
+    should "find_all_by_group_name - generate messages objects if array" do
+      mock_ecircle_client do |client|
+        client.lookup_messages(:lookupParams => { :groupName => "group name" }) do
+          [{ :id => :one}, { :id => :two}, { :id => :three}]
+        end
+
+        result = Ecircle::Message.find_all_by_group_name("group name")
+        assert_equal 3, result.count
+        assert_equal :one, result.first.id
+        assert_equal :two, result[1].id
+        assert_equal :three, result.last.id
+      end
+    end
+
+    should "do a delete" do
+      mock_ecircle_client do |client|
+        msg = Ecircle::Message.new(:id => "fubar")
+        client.delete_message(:messageId => "fubar") { "this is not returned" }
+        assert_equal true, msg.delete
+      end
+    end
+
+    should "delete: capture permission denied fault and return false" do
+      mock_ecircle_client do |client|
+        msg = Ecircle::Message.new(:id => "fubar")
+        client.delete_message(:messageId => "fubar") do
+          raise Ecircle::Client::PermissionDenied.new("fubar")
+        end
+        assert_equal false, msg.delete
+      end
+    end
+
+    should "delete: propagate other exceptions up" do
+      mock_ecircle_client do |client|
+        msg = Ecircle::Message.new(:id => "fubar")
+        client.delete_message(:messageId => "fubar") do
+          raise _soap_fault("Some other unknonwn exception")
+        end
+
+        assert_raises Savon::SOAP::Fault do
+          msg.delete
+        end
+      end
+    end
+
+    should "return a group object if group_id defined" do
+      msg = Ecircle::Message.new(:group_id => "fubar")
+      mock(Ecircle::Group).find_by_id("fubar") { "hi there" }
+      assert_equal "hi there", msg.group
+    end
+
+    should "nil if group_id is set to nil" do
+      msg = Ecircle::Message.new(:group_id => nil)
+      mock(Ecircle::Group).find_by_id.times(0)
+      assert_equal nil, msg.group
+    end
+
+    should "nil if group_id not set" do
+      msg = Ecircle::Message.new(:id => "fubar")
+      mock(Ecircle::Group).find_by_id.times(0)
+      assert_equal nil, msg.group
+    end
+
+    context "send_to_user" do
+      should "raise exception if unknown type" do
+        msg = Ecircle::Message.new(:type => "fubar")
+        assert_raises Ecircle::Message::MessageTypeUnknown do
+          msg.send_to_user nil
+        end
+      end
+
+      should "use single message if no parameters" do
+        mock_ecircle_client do |client|
+          msg     = Ecircle::Message.new(:type => 'single', :id => "fubar")
+          user    = Ecircle::User.new
+          user.id = "snafu"
+
+          client.send_single_message_to_user(:singleMessageId => "fubar",
+                                             :userId => user.id)
+          result = msg.send_to_user user
+          assert_equal true, result.first
+          assert_equal nil, result.last
+        end
+      end
+
+      should "return false and the result if result != nil" do
+        mock_ecircle_client do |client|
+          msg     = Ecircle::Message.new(:type => 'single', :id => "fubar")
+          user    = Ecircle::User.new
+          user.id = "snafu"
+
+          client.send_single_message_to_user(:singleMessageId => "fubar",
+                                             :userId => user.id) { "result not nil" }
+          result = msg.send_to_user user
+          assert_equal false, result.first
+          assert_equal "result not nil", result.last
+        end
+      end
+
+      should "use parameterized if there are paramters" do
+        mock_ecircle_client do |client|
+          msg     = Ecircle::Message.new(:type => 'single', :id => "fubar")
+          user    = Ecircle::User.new
+          user.id = "snafu"
+          parameters = {
+            :one => :two,
+            :three => :four
+          }
+          client.
+            send_parametrized_single_message_to_user(:singleMessageId => "fubar",
+                                                     :userId          => user.id,
+                                                     :names           => parameters.keys,
+                                                     :values          => parameters.values)
+          result = msg.send_to_user user, parameters
+          assert_equal true, result.first
+          assert_equal nil, result.last
+        end
+      end
+
+      should "throw exception if type is normal but group id does not exist" do
+        msg     = Ecircle::Message.new(:type => 'normal', :id => "fubar")
+        user    = Ecircle::User.new
+        user.id = "snafu"
+        assert_raises Ecircle::Message::MessageGroupNotDefined do
+          msg.send_to_user user
+        end
+      end
+
+      should "use group message if normal and group id is defined" do
+        mock_ecircle_client do |client|
+          msg     = Ecircle::Message.new(:type => 'normal', :group_id => "groupid",
+                                         :id => "fubar")
+          user    = Ecircle::User.new
+          user.id = "snafu"
+
+          client.send_group_message_to_user(:userId    => user.id, :messageId => "fubar",
+                                            :groupid   => "groupid")
+          result = msg.send_to_user user
+          assert_equal true, result.first
+          assert_equal nil, result.last
+        end
+      end
+    end
+  end
+end