eloqua 1.1.0

data/spec/lib/eloqua_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+class EloquaSpecReceving
+  class << self
+    def one_argument(from_delg, arg)
+
+    end
+
+    def one_argument2(from_delg, arg)
+
+    end
+
+    def three_argument(from_delg1, from_delg2, arg)
+
+    end
+
+    def three_argument2(from_delg1, from_delg2, arg)
+
+    end
+
+  end
+end
+
+describe Eloqua do
+  
+  context '#self.configure' do
+    it 'should provide self' do
+      save = nil
+      Eloqua.configure do |config|
+        config.should == Eloqua
+      end
+    end
+  end
+  
+  context '#self.authenticate' do
+    before do
+      Eloqua.authenticate('user', 'pass')
+    end
+    
+    it 'should have set username to user' do
+      Eloqua.user.should == 'user'
+    end
+    
+    it 'should have set password to pass' do
+      Eloqua.password.should == 'pass'
+    end
+    
+  end
+
+  context "#self.format_results_for_array" do
+    context "level 1 depth ending in single" do
+      let(:input) do
+        {
+          :one => :hit
+        }
+      end
+
+      let(:expected) { [:hit] }
+
+      it 'should return expected' do
+        result = subject.format_results_for_array(input, :one)
+        result.should == expected
+      end
+
+    end
+
+    context "level 3 depth ending in multiple" do
+
+      let(:input) do
+        {
+          :one => {
+            :two => {
+              :three => [:hit, :hit]
+            }
+          }
+        }
+      end
+
+      let(:expected) { [:hit, :hit] }
+
+      it 'should return expected' do
+        result = subject.format_results_for_array(input, :one, :two, :three)
+        result.should == expected
+      end
+    end
+
+    context "level 3 depth ending in single" do
+
+      let(:input) do
+        {
+          :one => {
+            :two => {
+              :three => [:hit]
+            }
+          }
+        }
+      end
+
+      let(:expected) { [:hit] }
+
+      it 'should return expected' do
+        result = subject.format_results_for_array(input, :one, :two, :three)
+        result.should == expected
+      end
+    end
+  end
+
+  context "#self.delegate_with_args" do
+
+    let(:receiving) do
+      EloquaSpecReceving
+    end
+
+    let(:sending) do
+      Class.new do
+        class << self
+          def one
+            1
+          end
+
+          def two
+            2
+          end
+        end
+      end
+    end
+
+    context 'with multiple delegated methods and single argument method' do
+      before do
+        Eloqua.delegate_with_args(sending, receiving, [:one_argument, :one_argument1], [:two])
+      end
+
+      specify { sending.should respond_to(:one_argument) }
+      specify { sending.should respond_to(:one_argument1) }
+
+      it 'should delegate method arguments to receiving' do
+        flexmock(receiving).should_receive(:one_argument).with(2, 'arg').once
+        sending.one_argument('arg')
+      end
+
+      it 'should delegate method arguments to receiving on other methods' do
+        flexmock(receiving).should_receive(:one_argument1).with(2, 'arg').once
+        sending.one_argument1('arg')
+      end
+
+    end
+
+    context 'with multiple delegated methods and arguments' do
+      before do
+        Eloqua.delegate_with_args(sending, receiving, [:three_argument, :three_argument1], [:one, :two])
+      end
+
+      specify { sending.should respond_to(:three_argument) }
+      specify { sending.should respond_to(:three_argument1) }
+
+      it 'should delegate method arguments to receiving' do
+        flexmock(receiving).should_receive(:three_argument).with(1, 2, 'arg').once
+        sending.three_argument('arg')
+      end
+
+      it 'should delegate method arguments to receiving on other methods' do
+        flexmock(receiving).should_receive(:three_argument1).with(1, 2, 'arg').once
+        sending.three_argument1('arg')
+      end
+
+    end
+
+
+  end
+
+end

data/spec/shared/attribute_map.rb

@@ -0,0 +1,173 @@
+shared_examples_for "uses attribute map" do
+  
+
+  context "#self.map_attribute" do
+
+    before do
+      @class = Class.new(subject) do
+        map :name => 'C_Name', :id => 'ContactID'
+      end
+    end
+
+    it 'should return value in attribute_map when given a key exists' do
+      @class.map_attribute(:name).should == :C_Name
+    end
+
+    it 'should return given value when key does not exist within attribute_map' do
+      @class.map_attribute(:Cezar).should == 'Cezar'
+    end
+
+  end
+
+  context "#self.attribute_map" do
+    specify { subject.attribute_map.class == Hash }
+
+    context "when inherited entity attribute map is cloned by not the same object" do
+      before do
+        @super = Class.new(subject)
+        @super.attribute_map[:id] = 'ContactID'
+        @child = Class.new(@super)
+      end
+
+      it 'should have all the same keys' do
+        @child.attribute_map.keys.should == @super.attribute_map.keys 
+      end
+
+      it 'should have all the same values' do
+        @child.attribute_map.values.should == @super.attribute_map.values
+      end
+
+      it 'should not be the same object as parent' do
+        @child.attribute_map.object_id.should_not === @super.attribute_map.object_id
+      end
+
+    end
+    
+  end
+  
+  
+  context "#self.map" do
+
+    before do
+      @class = Class.new(Eloqua::RemoteObject) do
+        self.remote_type = Eloqua::Api.remote_type('Contact')
+      end      
+    end
+
+    it 'should be able to use map on the class level to map attributes' do
+      @class.map :id => 'C_Attribute'
+      @class.attribute_map[:id].should == :C_Attribute
+    end
+
+    it 'should be able to override existing maps' do
+      @class.map :id => 'not_me'
+      @class.map :id => 'me'
+      @class.attribute_map[:id].should == :me
+    end
+    
+    context 'when reverse' do
+      it 'should also add the reverse to attribute_map_reverse' do
+        @class.map :Contact => 'name'
+        @class.map :IDC => 'id', :Real => 'email'
+
+        reverse = {
+          :name => :Contact,
+          :id => :IDC,
+          :email => :Real
+        }.with_indifferent_access
+        @class.attribute_map_reverse.should == reverse
+      end
+    end
+
+  end  
+  
+  context "#map_attributes" do
+    let(:input) do
+      {
+          :C_EmailAddress => 'email@address.com',
+          :ContactID => '1',
+          :normal_id => 'wow'
+      }.with_indifferent_access
+    end
+
+    let(:expected) do
+      {
+          :email_address => 'email@address.com',
+          :id => '1',
+          :normal_id => 'wow'
+      }.with_indifferent_access
+    end
+
+    let(:reverse) do
+      {
+        :email_address => 'C_EmailAddress',
+        :id => 'ContactID',
+        :normal_id => 'normal_id'
+      }.with_indifferent_access
+    end
+
+    before do
+      klass_object = Class.new(subject) do
+        map :ContactID => 'id'
+      end
+      @klass = klass_object.new
+      @result = @klass.send(:map_attributes, input)
+    end
+
+    it 'should map attributes from CamelCase format to snake_case format' do
+      @result.should == expected
+    end
+
+    it 'should store the original key names in attribute_keys_to_eloqua' do
+      @klass.instance_reverse_keys.should == reverse
+    end
+
+    context "#reverse_map_attributes" do
+    
+      context "when given valid input" do
+        before do
+          @reversed = @klass.send(:reverse_map_attributes, @result)
+        end
+
+        it 'should be able to reverse map_attributes back into input' do
+          @reversed.should == input  
+        end          
+      end
+
+      context "when given invalid input" do
+        let(:input) do
+          {
+            :id => '1',
+            :phone_field => 'phoney'
+          }
+        end
+
+        let(:expected) do
+          {
+            :ContactID => '1',
+            :phone_field => 'phoney'
+          }.with_indifferent_access
+        end
+
+        let(:klass) do
+          Class.new(subject) do
+            map :ContactID => 'id'
+          end
+        end
+
+        before do
+          object = klass.new
+          object.send(:map_attributes, {})
+          @result = object.send(:reverse_map_attributes, input)
+        end
+
+        it "should use given key when it is not known" do
+          @result.should == expected
+        end
+        
+      end
+    
+    end
+
+  end  
+end

data/spec/shared/class_to_api_delegation.rb

@@ -0,0 +1,50 @@
+# This is for testing the xml syntax given to the remote objects
+# Actual response tests (with fixtures) should be done in the 
+# Entity or Asset spec's
+
+shared_examples_for "class level delegation of remote operations for" do |remote_group|
+  
+  before do
+    @remote_group = remote_group
+  end
+  
+  let(:email) { 'test@email.com' }
+  
+  let(:dynamic_key) { ("dynamic_#{remote_group}".to_sym) }
+  let(:field_key) { "#{remote_group}_fields".to_sym }
+
+  group_delegation = Eloqua::Api::Service.group_methods
+  type_delegation = Eloqua::Api::Service.type_methods
+  group_type_delegation = Eloqua::Api::Service.group_type_methods
+
+  group_delegation.each do |method|
+    context "#self.#{method}" do
+      it "should delegate #{method} to Eloqua::Api::Service with group name" do
+        flexmock(Eloqua::Api::Service).should_receive(method).\
+            with(subject.remote_group).once
+        subject.send(method)
+      end
+    end
+  end
+
+  group_type_delegation.each do |method|
+    context "#self.#{method}" do
+      it "should delegate #{method} to Eloqua::Api::Service with group name" do
+        flexmock(Eloqua::Api::Service).should_receive(method).\
+            with(subject.remote_group, subject.remote_type).once
+        subject.send(method)
+      end
+    end
+  end
+
+  type_delegation.each do |method|
+    context "#self.#{method}" do
+      it "should delegate #{method} to Eloqua::Api::Service with group name" do
+        flexmock(Eloqua::Api::Service).should_receive(method).\
+            with(subject.remote_type).once
+        subject.send(method)
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require "bundler/setup"
+require 'flexmock'
+
+require 'net/http'
+require 'net/https'
+
+Bundler.require :default, :test
+
+require 'rspec'
+require 'timecop'
+require 'eloqua'
+require 'savon_spec'
+
+unless defined?(ELOQUA_LIB)
+  ELOQUA_LIB = File.dirname(__FILE__) + '/../lib'
+  $: << ELOQUA_LIB
+end
+
+Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each {|support| require support}
+Dir[File.dirname(__FILE__) + '/shared/**/*.rb'].each {|support| require support}
+
+Savon.configure do |config|
+  config.log = false
+  config.raise_errors = false
+end
+
+RSpec.configure do |config|
+
+  include Eloqua::RSpec::Helper
+  Savon::Spec::Fixture.path = File.dirname(__FILE__) + '/fixtures/'
+
+  config.mock_with :flexmock
+
+  config.before do
+    # This is for adding actual authentication details.
+    # The core tests do not actually need to login as they
+    # operate on fixtures but we need to get the fixture data
+    # in the first place and for that valid authenticate is needed
+    initializer = File.dirname(__FILE__) + '/../eloqua_initializer.rb'
+    if(File.exist?(initializer))
+      load initializer
+    else
+      Eloqua.authenticate('company\\user', 'pass')
+    end
+  end
+
+end

data/spec/support/helper.rb

@@ -0,0 +1,73 @@
+module Eloqua
+  module RSpec
+    module Helper
+      
+      def soap_fixture(type, name, code = 200, headers = {})
+        body = Savon::Spec::Fixture.load(type, name)
+        httpi = HTTPI::Response.new(code, headers, body)
+        Savon::SOAP::Response.new(httpi)
+      end
+
+      def mock_eloqua_request(type, name, code = 200, headers = {})
+        mock = soap_fixture(type, name, code, headers)
+        flexmock(Eloqua::Api).should_receive(:send_remote_request).and_return(mock)
+      end
+      
+      def mock_response(type, name, code = 200, headers = {})
+        body = Savon::Spec::Fixture.load(type, name)
+        mock = HTTPI::Response.new(code, headers, body)
+        flexmock(HTTPI).should_receive(:post).and_return(mock)
+      end
+
+
+      def mock_api_request(method = nil, xml_body = nil, result = nil)
+        mocked_object = subject
+
+        if(mocked_object.respond_to?(:api))
+          mocked_object = mocked_object.api
+        end
+        
+        if(!xml_body && !result)
+          # No with expectation
+          result = method
+          flexmock(mocked_object).should_receive(:request).\
+                              and_return(result).once
+        else
+          # with expectation
+          flexmock(mocked_object).should_receive(:request).\
+                              with(method, xml_body).\
+                              and_return(result).once      
+        end
+      end
+      
+      def xml!(&block)
+        Eloqua::Api.builder(&block)
+      end
+
+      def group_name
+        (respond_to?(:remote_group))? remote_group : group
+      end
+      
+      def remote_type
+        "#{group_name}Type"
+      end
+
+      def dynamic_type
+        "Dynamic#{group_name.to_s.camelize}"
+      end
+
+      def tag_with_type(tag)
+        "#{tag}_#{group_name}".to_sym
+      end
+
+      def remote_method(method)
+        if(group_name == :entity)
+          method.to_sym
+        else
+          ("#{method}_#{group_name}").to_sym
+        end
+      end 
+      
+    end
+  end
+end