responsys-api 0.0.3 → 0.0.4

data/lib/responsys_api.rb

@@ -1,4 +1,11 @@
-require 'responsys/responsys_api'
-require 'responsys/configuration'
-require 'responsys/helper'
-require 'savon/savon_api'
+require "i18n"
+
+I18n.load_path << File.expand_path("../responsys/i18n/en.yml", __FILE__)
+I18n.locale = :en
+I18n.enforce_available_locales = false
+
+require "responsys/exceptions/all"
+require "responsys/helper"
+require "responsys/configuration"
+require "responsys/api/client"
+require "responsys/member"

data/responsys-api.gemspec

@@ -1,14 +1,14 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "responsys-api"
-  spec.version       = "0.0.3"
+  spec.version       = "0.0.4"
   spec.authors       = ["Dan DeMeyere", "Florian Lorrain", "Morgan Griggs", "Mike Rocco"]
-  spec.email         = ["dan@thredup.com", "florain.lorrain@thredup.com", "morgan@thredup.com", "michael.rocco@thredup.com"]
-  spec.description   = 'A gem to integrate with the Responsys SOAP API'
-  spec.summary       = 'Write a proper summary'
+  spec.email         = ["dan@thredup.com", "florian.lorrain@thredup.com", "morgan@thredup.com", "michael.rocco@thredup.com"]
+  spec.description   = "A gem to integrate with the Responsys SOAP API"
+  spec.summary       = "Write a proper summary"
   spec.homepage      = "https://github.com/dandemeyere/responsys-api"
   spec.license       = "MIT"
 
@@ -17,9 +17,12 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "rubyntlm", "~> 0.4.0"
-  spec.add_dependency "savon", "~> 2.6.0"
+  spec.add_dependency "rubyntlm", "~> 0.4"
+  spec.add_dependency "savon", "~> 2.6"
+  spec.add_dependency "i18n", "~> 0.6"
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency 'rspec', '3.0.0'
+  spec.add_development_dependency "rake", "~> 10.3"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "vcr", "~> 2.5"
+  spec.add_development_dependency "webmock", "~> 1.9"
 end

data/spec/api/campaign_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper.rb"
+require "responsys/api/client"
+
+describe Responsys::Api::Campaign do 
+
+  context "Trigger Message" do
+    before(:all) do
+      VCR.use_cassette("api/campaign/login") do
+        @client = Responsys::Api::Client.instance
+      end
+    end
+
+    before(:each) do
+      @campaign = Responsys::Api::Object::InteractObject.new("fake","fake")
+      @recipient = Responsys::Api::Object::Recipient.new(emailAddress: 'fake@thredup.com')
+      @recipientData = Responsys::Api::Object::RecipientData.new(@recipient)
+    end
+
+    it "should pass api_method a message Hash" do
+      VCR.use_cassette("api/campaign/login") do
+        expect(@client).to receive(:api_method).with(anything, be_a_kind_of(Hash))
+        @client.trigger_message(@campaign, [@recipientData])
+      end
+    end
+  end
+
+end

data/spec/api/client_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper.rb"
+require "responsys/api/client"
+require "singleton"
+
+describe Responsys::Api::Client do
+
+  context "expired session" do
+    before(:example) do
+      allow_any_instance_of(Responsys::Api::Client).to receive(:login).and_return(nil)
+
+      Responsys::Api::Client.instance.instance_variable_set(:@session_id, "fake_session_id")
+      Responsys::Api::Client.instance.instance_variable_set(:@jsession_id, HTTPI::Cookie.new("jsessionid=fakejsessionid; Path=/; HttpOnly"))
+      Responsys::Api::Client.instance.instance_variable_set(:@header, { SessionHeader: { sessionId: "fake_session_id" } })
+    end
+
+    it "should ask for a new session" do
+      VCR.use_cassette("api/client/expired_session") do
+        expect_any_instance_of(Responsys::Api::Client).to receive(:login).exactly(1).times.and_call_original
+        result = Responsys::Api::Client.instance.api_method(:list_folders)
+
+        expect(result[:status]).to eq("ok")
+      end
+    end
+
+    it "should rerun the request with a new session id" do
+      VCR.use_cassette("api/client/expired_session") do
+        expect_any_instance_of(Responsys::Api::Client).to receive(:login).exactly(1).times.and_call_original
+
+        expect(Responsys::Api::Client.instance.header[:SessionHeader][:sessionId]).to eq("fake_session_id")
+
+        Responsys::Api::Client.instance.api_method(:list_folders)
+
+        expect(Responsys::Api::Client.instance.header[:SessionHeader][:sessionId]).to eq("5GXdGHHKOLqsf4ukCpwQYz3B0b")
+      end
+    end
+
+  end
+
+  context "Authentication" do
+    let(:savon_client) { double("savon client") }
+
+    before(:context) do
+      @credentials = { username: "your_responsys_username", password: "your_responsys_password" }
+    end
+
+    after(:context) do
+      Singleton.__init__(Responsys::Api::Client)
+    end
+
+    it "should set the credentials" do
+      allow_any_instance_of(Responsys::Api::Client).to receive(:login).and_return(nil)
+
+      responsys = Responsys::Api::Client.instance
+
+      expect(responsys.credentials).to eq({ username: "your_responsys_username", password: "your_responsys_password" })
+    end
+
+    context "login" do
+      before(:example) do
+        response = double("response")
+
+        cookies = %w(fake_jsession_id)
+        body = {
+          login_response: {
+            result: {
+              session_id: "fake_session_id"
+            }
+          }
+        }
+
+        allow(response).to receive(:body).and_return(body)
+        allow(response).to receive(:http).and_return(double("cookies", cookies: cookies))
+
+        allow(Savon).to receive(:client).with({ wsdl: "https://wsxxxx.responsys.net/webservices/wsdl/ResponsysWS_Level1.wsdl", element_form_default: :qualified }).and_return(savon_client) #Avoid the verification of the wsdl
+        allow_any_instance_of(Responsys::Api::Client).to receive(:run).with("login", @credentials).and_return(response) #Verification of credentials
+        allow(savon_client).to receive(:call).with(:login, @credentials ).and_return(response) #Actual login call
+
+        Singleton.__init__(Responsys::Api::Client)
+      end
+
+      it "should set the session ids" do
+        instance = Responsys::Api::Client.instance #Get it
+
+        expect(instance.header).to eq({ SessionHeader: { sessionId: "fake_session_id" } }) #Test the ids are right
+        expect(instance.jsession_id).to eq("fake_jsession_id")
+      end
+    end
+
+    context "logout" do
+      before(:example) do
+        allow(Savon).to receive(:client).with({ wsdl: "https://wsxxxx.responsys.net/webservices/wsdl/ResponsysWS_Level1.wsdl", element_form_default: :qualified }).and_return(savon_client) #Avoid the verification of the wsdl
+        allow_any_instance_of(Responsys::Api::Client).to receive(:login).and_return(nil) #Avoid credentials checking
+
+        Singleton.__init__(Responsys::Api::Client)
+      end
+
+      it "should logout" do
+        instance = Responsys::Api::Client.instance #Get it
+
+        allow(Responsys::Helper).to receive(:format_response_hash).with(any_args) #We dont want to parse the response
+        expect(savon_client).to receive(:call).with(:logout, anything) #Check the call is actually being done
+
+        instance.logout
+      end
+    end
+  end
+end

data/spec/api/list_spec.rb

@@ -0,0 +1,71 @@
+require "spec_helper.rb"
+
+describe Responsys::Api::List do
+
+  before(:context) do
+    @list = Responsys::Api::Object::InteractObject.new("another_test_folder", "test_list")
+    @query_column_email = Responsys::Api::Object::QueryColumn.new("EMAIL_ADDRESS")
+    @multiple_users_email = %w(user@email.com user2@email.com user3@email.com)
+    @user1_email = "user@email.com"
+    @user1_mobile = "0000000001"
+    @user2_mobile = "0000000000"
+
+    VCR.use_cassette("api/list/login") do
+      Responsys::Api::Client.instance.login
+    end
+  end
+
+  context "Retrieve info from list with multiple users" do
+
+    it "should get a ok status" do
+      VCR.use_cassette("api/list/retrieve") do
+        response = Responsys::Api::Client.instance.retrieve_list_members(@list, @query_column_email, %w(EMAIL_ADDRESS_ MOBILE_NUMBER_), @multiple_users_email)
+
+        expect(response[:status]).to eq("ok")
+      end
+    end
+
+    it "should get a value from the data" do
+      VCR.use_cassette("api/list/retrieve") do
+        response = Responsys::Api::Client.instance.retrieve_list_members(@list, @query_column_email, %w(EMAIL_ADDRESS_ MOBILE_NUMBER_), @multiple_users_email)
+
+        expect(response[:data][2][:EMAIL_ADDRESS_]).to eq("user2@email.com")
+      end
+    end
+
+    it "should get a nil value" do
+      VCR.use_cassette("api/list/retrieve") do
+        response = Responsys::Api::Client.instance.retrieve_list_members(@list, @query_column_email, %w(EMAIL_ADDRESS_ MOBILE_NUMBER_), @multiple_users_email)
+
+        expect(response[:data][1][:MOBILE_NUMBER_]).to be(nil)
+      end
+    end
+
+    it "should return a single result" do
+      VCR.use_cassette("api/list/retrieve_single") do
+        response = Responsys::Api::Client.instance.retrieve_list_members(@list, @query_column_email, %w(EMAIL_ADDRESS_ MOBILE_NUMBER_), [@user1_email])
+
+        expect(response[:data][0][:EMAIL_ADDRESS_]).to eq(@user1_email)
+      end
+    end
+
+    it "should return a single field in a single record" do
+      VCR.use_cassette("api/list/retrieve_single_single") do
+        response = Responsys::Api::Client.instance.retrieve_list_members(@list, @query_column_email, %w(EMAIL_ADDRESS_), [@user1_email])
+
+        expect(response[:data][0][:EMAIL_ADDRESS_]).to eq(@user1_email)
+      end
+    end
+  end
+
+  context "Merge list members" do
+    it "should reject no record" do
+      VCR.use_cassette("api/list/merge") do
+        data = [{ Email_Address_: @user1_email, Mobile_Number_: @user1_mobile }, { Mobile_Number_: @user2_mobile, Customer_ID_: "" }]
+        response = Responsys::Api::Client.instance.merge_list_members(@list, Responsys::Api::Object::RecordData.new(data), merge_rule = Responsys::Api::Object::ListMergeRule.new(matchColumnName1: "Mobile_Number_"))
+
+        expect(response[:data][0][:result][:rejected_count].to_i).to eq(0)
+      end
+    end
+  end
+end

data/spec/api/object/recipient_data_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper.rb"
+require "responsys/api/client"
+
+describe Responsys::Api::Object::RecipientData do 
+
+
+  context "new RecipientData" do
+
+    before(:each) do
+      @recipient = Responsys::Api::Object::Recipient.new
+      @recipient_data = Responsys::Api::Object::RecipientData.new(@recipient)
+    end
+
+    it "should have a recipient attribute of type Recipient" do
+      expect(@recipient_data.recipient).to be_a(Responsys::Api::Object::Recipient)
+    end
+
+    it "should have an optional_data attribute of type Array" do
+      expect(@recipient_data.optional_data).to be_a(Responsys::Api::Object::OptionalData)
+    end
+  end
+
+
+  context "RecipientData to_api method" do
+
+    before(:each) do
+      @recipient = Responsys::Api::Object::Recipient.new
+      @recipient_data = Responsys::Api::Object::RecipientData.new(@recipient)
+    end
+
+    it "should be of type Hash" do
+      expect(@recipient_data.to_api).to be_a(Hash)
+    end
+
+    it "should have a recipient attribute of type Hash" do
+      expect(@recipient_data.to_api[:recipient]).to be_a(Hash)
+    end
+
+    it "should have an optionalData attribute of type Array" do
+      expect(@recipient_data.to_api[:optionalData]).to be_a(Hash)
+    end
+  end
+end

data/spec/api/object/recipient_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper.rb"
+require "responsys/api/client"
+
+describe Responsys::Api::Object::Recipient do 
+
+
+  context "new recipient" do
+
+    before(:each) do
+      @recipient = Responsys::Api::Object::Recipient.new
+    end
+
+    it "should have list_name attribute of type InteractObject" do
+      expect(@recipient.list_name).to be_a(Responsys::Api::Object::InteractObject)
+    end
+
+    it "should have recipient_id attribute" do
+      expect(@recipient.recipient_id).to be
+    end
+
+    it "should have customer_id attribute" do
+      expect(@recipient.customer_id).to be
+    end
+
+    it "should have email_address attribute" do
+      expect(@recipient.email_address).to be
+    end
+
+    it "should have mobile_number attribute" do
+      expect(@recipient.mobile_number).to be
+    end
+
+    it "should have email_format attribute of type EmailFormat" do
+      expect(@recipient.email_format).to be_a(Responsys::Api::Object::EmailFormat)
+    end
+  end
+
+  context "recipient to_api" do
+
+    before(:each) do
+      @recipient = Responsys::Api::Object::Recipient.new
+    end
+
+    it "should have listName attribute of type Hash" do
+      expect(@recipient.to_api[:listName]).to be_a(Hash)
+    end
+
+    it "should have recipientId attribute " do
+      expect(@recipient.to_api[:recipientId]).to be
+    end
+
+    it "should have customerId attribute " do
+      expect(@recipient.to_api[:customerId]).to be
+    end
+
+    it "should have emailAddress attribute " do
+      expect(@recipient.to_api[:emailAddress]).to be
+    end
+
+    it "should have mobileNumber attribute " do
+      expect(@recipient.to_api[:mobileNumber]).to be
+    end
+
+    it "should have EmailFormat attribute of type String" do
+      expect(@recipient.to_api[:emailFormat]).to be_a(String)
+    end
+  end
+end

data/spec/api/object/record_data_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper.rb"
+
+describe Responsys::Api::Object::RecordData  do
+
+  context "Constructor params handling" do
+    before(:each) do
+      @data = [{ field1: "value11", field2: "value12" }, { field2: "value22", field3: "value23" }]
+      @field_names = [:field1, :field2, :field3]
+      @record1 = ["value11", "value12", ""]
+      @record2 = ["", "value22", "value23"]
+
+      @object = Responsys::Api::Object::RecordData.new(@data)
+    end
+
+    it "should handle transform the constructor params" do
+      expect(@object.field_names).to eq(@field_names)
+    end
+
+    it "should transform correctly the object to the api representation" do
+      expect(@object.to_api).to eq({ fieldNames: @field_names, records: [{ fieldValues: @record1 }, { fieldValues: @record2 }] })
+    end
+
+    it "should raise an exception if the constructor parameter is not an array" do
+      expect{Responsys::Api::Object::RecordData.new("")}.to raise_exception(Responsys::Exceptions::ParameterException, "The data you provided is not an array")
+    end
+  end
+
+end

data/spec/api/table_spec.rb

@@ -0,0 +1,111 @@
+require "spec_helper.rb"
+
+describe Responsys::Api::Table do
+
+  before(:example) do
+    @profile_extension = Responsys::Api::Object::InteractObject.new("another_test_folder", "test_profile_extension")
+    @query_column_riid = Responsys::Api::Object::QueryColumn.new("RIID")
+    @query_column_email = Responsys::Api::Object::QueryColumn.new("EMAIL_ADDRESS")
+    @fields = %w(RIID_ EMAIL_ADDRESS)
+    @user_riid = 398426
+    @user_email = "user2@email.com"
+
+    VCR.use_cassette("api/profile_extension/login") do
+      Responsys::Api::Client.instance.login
+    end
+  end
+
+  context "create table" do
+    before(:all) do
+      @table = Responsys::Api::Object::InteractObject.new("another_test_folder", "table_#{Time.now.to_i}")
+      @table_with_pk = Responsys::Api::Object::InteractObject.new("another_test_folder", "table_with_pk_#{Time.now.to_i}")
+    end
+
+    it "should create a table" do
+      VCR.use_cassette("api/table/create") do
+        fields = [
+          Responsys::Api::Object::Field.new("field1", Responsys::Api::Object::FieldType.new("STR500"), custom = false, data_extraction_key = false),
+          Responsys::Api::Object::Field.new("field2", Responsys::Api::Object::FieldType.new("NUMBER"), custom = false, data_extraction_key = false),
+          Responsys::Api::Object::Field.new("field3", Responsys::Api::Object::FieldType.new("TIMESTAMP"), custom = false, data_extraction_key = false),
+        ]
+        response = Responsys::Api::Client.instance.create_table(@table, fields)
+
+        expect(response[:result]).to be(true)
+      end
+    end
+
+    it "should delete the previous table" do
+      VCR.use_cassette("api/table/delete") do
+        response = Responsys::Api::Client.instance.delete_table(@table)
+
+        expect(response[:result]).to be(true)
+      end
+    end
+
+    it "should create a table with pk" do
+      VCR.use_cassette("api/table/create_with_pk") do
+        fields = [
+          Responsys::Api::Object::Field.new("field1", Responsys::Api::Object::FieldType.new("STR500"), custom = false, data_extraction_key = false),
+          Responsys::Api::Object::Field.new("field2", Responsys::Api::Object::FieldType.new("NUMBER"), custom = false, data_extraction_key = false),
+          Responsys::Api::Object::Field.new("field3", Responsys::Api::Object::FieldType.new("TIMESTAMP"), custom = false, data_extraction_key = false),
+        ]
+        response = Responsys::Api::Client.instance.create_table_with_pk(@table_with_pk, fields, %w(field1))
+
+        expect(response[:result]).to be(true)
+      end
+    end
+
+    it "should delete the previous table with pk" do
+      VCR.use_cassette("api/table/delete_with_pk") do
+        response = Responsys::Api::Client.instance.delete_table(@table_with_pk)
+
+        expect(response[:result]).to be(true)
+      end
+    end
+  end
+
+  context "retrieve_profile_extension_records" do
+
+    it "should set the status to ok" do
+      VCR.use_cassette("api/profile_extension/retrieve_profile_extension_records") do
+        response = Responsys::Api::Client.instance.retrieve_profile_extension_records(@profile_extension, @query_column_riid, @fields, %W(#{@user_riid}))
+
+        expect(response[:status]).to eq("ok")
+      end
+    end
+
+    it "should return one record" do
+      VCR.use_cassette("api/profile_extension/retrieve_profile_extension_records") do
+        response = Responsys::Api::Client.instance.retrieve_profile_extension_records(@profile_extension, @query_column_riid, @fields, %W(#{@user_riid}))
+
+        expect(response[:data].length).to eq(1)
+      end
+    end
+
+    it "should return two key-value pairs" do
+      VCR.use_cassette("api/profile_extension/retrieve_profile_extension_records") do
+        response = Responsys::Api::Client.instance.retrieve_profile_extension_records(@profile_extension, @query_column_riid, @fields, %W(#{@user_riid}))
+
+        expect(response[:data][0].length).to eq(2)
+      end
+    end
+
+    it "should add (merge into) a profile extension member" do
+      VCR.use_cassette("api/profile_extension/merge_profile_extension_records") do
+        record_data = Responsys::Api::Object::RecordData.new([{EMAIL_ADDRESS_: @user_email, MONTHLY_PURCH: 3000}])
+        response = Responsys::Api::Client.instance.merge_into_profile_extension(@profile_extension, record_data, "EMAIL_ADDRESS", true)
+
+        expect(response[:status]).to eq("ok")
+      end
+    end
+
+    it "should delete a profile extension member" do
+      VCR.use_cassette("api/profile_extension/retrieve_profile_extension_records") do
+        response = Responsys::Api::Client.instance.delete_profile_extension_members(@profile_extension, @query_column_email, %W{#{@user_email}})
+
+        expect(response[:status]).to eq("ok")
+      end
+    end
+
+  end
+end