eloqua 1.1.0

data/spec/lib/eloqua/api_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'pp'
+
+
+describe Eloqua::Api do
+
+  subject { Eloqua::Api }
+
+  before do
+    subject.reset_clients
+  end
+  
+  context '#builder' do
+    
+    it 'should call Eloqua::Builder::Xml.create' do
+      flexmock(Eloqua::Builder::Xml).should_receive(:create).once
+      subject.builder
+    end
+        
+  end
+
+  context "#request" do
+
+    context "When returning multiple records" do
+
+      before do
+        mock_response(:retrieve, :contact_multiple)
+        @response = subject.request(:service, :retrieve) do
+        end
+      end
+
+      it 'should return dynamic entity key as the top level hash' do
+        @response.should have_key(:dynamic_entity)
+      end
+
+      it "should have stored response in #last_response" do
+        body = Savon::Spec::Fixture.load(:retrieve, :contact_multiple)
+        subject.last_response.should == body
+      end
+
+      it "should have stored response in #last_request" do
+        subject.last_request.should_not be_blank
+      end
+      
+
+    end
+
+  end
+  
+  context "#raise_response_errors" do
+
+    context "when response given is an HTTP error" do
+      it "should raise Eloqua::HTTPError" do
+        
+      end
+    end
+
+    context "when response given is a SOAP Fault" do
+
+      it "should raise an SoapError" do
+        mock_response(:query, :fault)
+        lambda { @response = subject.request(:service, :query) }.should raise_exception(Eloqua::SoapError)
+      end
+
+    end
+
+  end
+
+  context "#client" do
+    
+    context 'when no Eloqua.user or Eloqua.password is set' do
+      
+      before do
+        Eloqua.authenticate(nil, nil)
+      end
+      
+      it 'should raise RuntimeError about missing user or password' do
+        lambda { subject.client(:service) }.should raise_exception(RuntimeError, 'Eloqua.user or Eloqua.password is not set see Eloqua.authenticate')
+      end      
+      
+    end
+
+    before do
+      @connection = subject.client(:email)
+    end
+
+    it 'should return a Savon::Client' do
+      @connection.class.should == Savon::Client
+    end
+
+    it "should return a savon instance of the given wsdl type" do
+      @connection.wsdl.instance_variable_get(:@document).should == subject::WSDL[:email]
+    end
+
+    it 'should have wsse username set to Eloqua.user constant' do
+      @connection.wsse.username.should == Eloqua.user
+    end
+
+    it 'should have wsse password set to Eloqua.password constant' do
+      @connection.wsse.password.should == Eloqua.password
+    end
+
+    it "should have an :arr namespace for arrays" do
+      
+    end
+
+  end
+
+  context "#remote_type" do
+
+    before do
+      @entity = subject.remote_type('Contact')
+    end
+
+    it "should be a hash" do
+      @entity.class.should == Hash
+    end
+
+    it "should have an ID of 0" do
+      @entity[:id].should == 0
+    end
+
+    it "should have a Name equal to Contact" do
+      @entity[:name].should == 'Contact'
+    end
+
+    it "should have Type equal to Base" do
+      @entity[:type].should == 'Base'
+    end
+
+  end
+
+end

data/spec/lib/eloqua/asset_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Eloqua::Asset do
+  
+  subject do
+    Class.new(Eloqua::Asset) do
+      self.remote_type = api.remote_type('ContactGroupName', 'ContactGroup', 0)
+      def self.name
+        'ContactGroup'
+      end
+    end
+  end
+
+  let(:entity) do
+    Class.new(Eloqua::Entity) do
+      self.remote_type = api.remote_type('Contact')
+    end
+  end
+
+  let(:object) { subject.new(:id => 1) }
+
+
+  context "#member_operation" do
+
+    let(:input) { [entity.new(:id => 1  )] }
+
+    context "when given non entity" do
+      it "should raise argument error" do
+        lambda do
+          object.send(:member_operation, :add_group_member, nil)
+        end.should raise_exception(ArgumentError, /Eloqua\:\:Entity/)
+      end
+    end
+
+    context "when given unpersisted entity" do
+      it "should raise argument error" do
+        lambda do
+          object.send(:member_operation, :add_group_member, Eloqua::Entity)
+        end.should raise_exception(ArgumentError, /Eloqua\:\:Entity/)
+      end
+    end
+
+    context "#add_member" do
+      it 'should delegate call to member_operation' do
+        flexmock(object).should_receive(:member_operation).with(:add_group_member, *input).once
+        object.add_member(*input)
+      end
+    end
+
+    context "#remove_member" do
+      it 'should delegate call to member_operation' do
+        flexmock(object).should_receive(:member_operation).with(:remove_group_member, *input).once
+        object.remove_member(*input)
+      end
+    end
+
+  end
+  
+  specify { subject.remote_group.should == :asset }
+
+  it_behaves_like 'class level delegation of remote operations for', :asset
+
+end

data/spec/lib/eloqua/builder/templates_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+describe Eloqua::Builder::Templates do
+
+  let(:xml) do
+    Eloqua::Builder::Xml.new
+  end
+
+  subject do
+    klass = Class.new
+    klass.send(:include, Eloqua::Builder::Templates)
+    klass
+  end
+
+  context "#define_builder_template" do
+
+    before do
+      subject.define_builder_template :iterator do |xml, list|
+      end
+    end
+
+    it 'should have saved block in builder_templates' do
+      subject.builder_templates.size.should == 1
+    end
+
+    it 'should be able to access block' do
+      subject.builder_templates[:iterator].class.should == Proc
+    end
+
+  end
+
+  context '#builder_template' do
+
+    context 'passing no arguments to template' do
+
+      before do
+        subject.define_builder_template :bigwow do |xml|
+          xml.big_wow("BANG!")
+        end
+      end
+
+      it 'should be able to use template to create xml' do
+        output = xml.omg(&subject.builder_template(:bigwow))
+        output.strip.should == '<omg><big_wow>BANG!</big_wow></omg>'
+      end
+
+    end
+
+    context 'passing arguments to template' do
+
+      before do
+        subject.define_builder_template :long do |xml, list|
+          list.each do |element|
+            xml.tag!(element[0], element[1])
+          end
+        end
+      end
+
+      it 'should take arguments and build output' do
+        output = xml.long(&subject.builder_template(:long, [ ['big', 'value'], ['small', 'value'] ]))
+        output.strip.should == '<long><big>value</big><small>value</small></long>'
+      end
+
+    end
+    
+  end
+
+end

data/spec/lib/eloqua/builder/xml_spec.rb

@@ -0,0 +1,254 @@
+require 'spec_helper'
+
+describe Eloqua::Builder::Xml do
+
+  def xml!(&block)
+    subject.create(&block)
+  end
+
+  subject { Eloqua::Builder::Xml }
+
+  let(:xml) do
+    subject.new(:namespace => 'wsdl')
+  end
+
+  it "should include Eloqua::Builder::Templates" do
+    subject.should include(Eloqua::Builder::Templates)
+  end
+
+  it 'should allow a block during new providing self' do
+    subject.new do |xml|
+      xml.is_a?(subject)
+    end
+  end
+
+  context "when default namespace options is set" do
+
+    let(:xml) do
+      subject.new(:namespace => 'wsdl')
+    end
+
+    it 'should output the default namespace with tag' do
+      output = xml.entities {}
+      output.strip.should == '<wsdl:entities></wsdl:entities>'
+    end
+
+    it 'should allow us to override the default namespace' do
+      output = xml.arr(:int) {}
+      output.strip.should == '<arr:int></arr:int>'
+    end
+
+  end
+
+  # Entity/Asset Helpers
+
+  context '#dynamic_object!' do
+
+    let(:expected) { '<DynamicAsset>content</DynamicAsset>' }
+
+    it 'should return expected xml' do
+      xml! {|xml| xml.dynamic_object!(:asset, 'content') }.should == expected
+    end
+
+  end
+
+  context '#object_type!' do
+    let(:expected) { '<AssetType>content</AssetType>' }
+
+    it 'should return expected xml' do
+      xml! {|xml| xml.object_type!(:asset, 'content') }.should == expected
+    end
+
+  end
+
+  context '#object_type_lower!' do
+    let(:expected) { '<assetType>content</assetType>' }
+
+    it 'should return expected xml' do
+      xml! {|xml| xml.object_type_lower!(:asset, 'content') }.should == expected
+    end
+
+  end
+
+  context '#object_collection!' do
+    let(:expected) { "<entities><one>1</one></entities>" }
+    it 'should return expected xml' do
+      xml! {|xml| xml.object_collection!(:entity) { xml.one('1') } }.should == expected
+    end
+  end
+
+  context "#self.create" do
+
+    let(:klass) do
+      Class.new(subject) do
+        define_builder_template(:zomg) do |xml|
+          xml.wow('zomg')
+        end
+      end
+    end
+
+    let(:xml_body) do
+      '<big>1</big><wow>zomg</wow>'
+    end
+
+    it 'should produce expected output' do
+      out = klass.create do |xml|
+        xml.big('1')
+        xml.template!(:zomg)
+      end
+      out.should == xml_body
+    end
+
+  end
+
+  context 'xml templates' do
+
+    share_examples_for "expected template output" do |template|
+
+      before do
+        @args = []
+        if(respond_to?(:args))
+          @args = args
+        elsif respond_to?(:input)
+          @args = [input]
+        end
+        builder = subject.new
+        @output = subject.create(&subject.builder_template(template, *@args))
+      end
+
+      it "should return :expected output from template :#{template}" do
+        @output.should == expected.to_s
+      end
+    end
+
+    let(:entity) do
+      Eloqua::Api.remote_type('Contact')
+    end
+
+    context ':object' do
+      let(:args) do
+        ['random', Eloqua::Api.remote_type('Contact'), 1]
+      end
+
+      let(:expected) do
+        xml! do |xml|
+          xml.random do
+            xml.RandomType do
+              xml.template!(:object_type, Eloqua::Api.remote_type('Contact'))
+            end
+            xml.Id(1)
+          end
+        end
+      end
+
+      it_behaves_like 'expected template output', :object
+
+    end
+
+    context ':dynamic' do
+
+      let(:args) do
+        ['entity', Eloqua::Api.remote_type('Contact'), 124194, {:C_Company => 'Lights of Apollo LLC'}]
+      end
+
+      let(:expected) do
+        subject.create do |xml|
+          xml.EntityType do
+            xml.template!(:object_type, entity)
+          end
+          xml.FieldValueCollection do
+            xml.template!(:fields, 'entity', args[3])
+          end
+          xml.Id(args[2])
+        end
+      end
+
+      it_behaves_like 'expected template output', :dynamic
+
+    end
+
+    context ':fields' do
+
+      let(:args) do
+        ['entity', input]
+      end
+
+      let(:input) do
+        list = {}
+        list[:C_EmailAddress] = 'james@localhost'
+        list
+      end
+
+
+      let(:expected) do
+        subject.create do |xml|
+          xml.EntityFields do
+            xml.InternalName('C_EmailAddress')
+            xml.Value('james@localhost')
+          end
+        end
+      end
+
+      it_behaves_like 'expected template output', :fields
+
+    end
+
+    context ':entity' do
+
+      let(:input) do
+        Eloqua::Api.remote_type('Contact')
+      end
+
+      let(:expected) do
+        subject.create do |xml|
+          xml.ID('0')
+          xml.Name('Contact')
+          xml.Type('Base')
+        end
+      end
+
+      it_behaves_like 'expected template output', :object_type
+
+    end
+
+    context ":array" do
+
+      let(:input) do
+        [1, 'string', '1', 'string']
+      end
+      let(:expected) do
+        subject.create do |xml|
+          xml.arr(:int, '1')
+          xml.arr(:string, 'string')
+          xml.arr(:string, '1')
+          xml.arr(:string, 'string')
+        end
+      end
+
+      it_behaves_like 'expected template output', :array
+
+    end
+
+    context ":int_array" do
+
+
+      let(:input) do
+        [1, 'ouch', 2, 'wow', '3']
+      end
+
+      let(:expected) do
+        subject.create do |xml|
+          xml.arr(:int, 1)
+          xml.arr(:int, 2)
+          xml.arr(:int, 3)
+        end
+      end
+
+      it_behaves_like 'expected template output', :int_array
+
+    end
+
+  end
+
+
+end