cupid 0.2.4 → 0.3.2

data/lib/cupid/response/format.rb

@@ -0,0 +1,53 @@
+class Cupid
+  module Response
+    class Format
+      IGNORE = [:partner_key, :object_id]
+      RENAME = {
+        :new_id        => :id,
+        :'@xsi:type'   => :type,
+        :parent_folder => :parent_data
+      }
+
+      def self.apply(data)
+        formatted = new data
+        formatted.data
+      end
+
+      attr_reader :data
+
+      def initialize(data)
+        @data = data
+        extract_nested_data
+        rename_fields
+        delete_ignored_fields
+        delete_empty_parents
+      end
+
+      private
+
+      def extract_nested_data
+        data.merge! data.delete(:object) if data[:object]
+      end
+
+      def rename_fields
+        RENAME.each do |old_name, new_name|
+          next unless data[old_name]
+          data[new_name] = data.delete old_name
+        end
+      end
+
+      def delete_ignored_fields(data=@data)
+        data.delete_if do |key, value|
+          delete_ignored_fields value if value.is_a? Hash
+          IGNORE.include? key
+        end
+      end
+
+      def delete_empty_parents
+        if (data[:parent_data] || {})[:id] == '0'
+          data.delete :parent_data
+        end
+      end
+    end
+  end
+end

data/lib/cupid/response/object.rb

@@ -0,0 +1,40 @@
+class Cupid
+  module Response
+    class Object
+      def self.fields(*names)
+        names.each do |name|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              data[:#{name}]
+            end
+          RUBY
+        end
+      end
+
+      attr_reader :data
+      fields :id, :customer_key
+
+      def initialize(data)
+        @data = data
+      end
+
+      # Hook into gyoku
+      def call
+        id
+      end
+
+      def type
+        instance_of?(Object) ? self[:type] : self.class
+      end
+
+      def ==(object)
+        return false unless object.is_a? Cupid::Response::Object
+        id and [id, type] == [object.id, object.type]
+      end
+
+      def [](field)
+        data[field]
+      end
+    end
+  end
+end

data/lib/cupid/retrieve.rb

@@ -0,0 +1,63 @@
+class Cupid
+  module Retrieve
+    LIST_FIELDS     = %w(ID ListName CustomerKey)
+    EMAIL_FIELDS    = %w(ID Name)
+    FOLDER_FIELDS   = %w(ID Name ParentFolder.ID ParentFolder.Name)
+    DELIVERY_FIELDS = %w(ID Status)
+    UI_EMAIL_FIELDS = %w(CustomerKey Name Email.ID EmailSubject CategoryID)
+
+    def emails(name=nil, *fields)
+      retrieve 'Email',
+        EMAIL_FIELDS + fields,
+        filter_email_like(name)
+    end
+
+    def ui_emails(folder=nil, *fields)
+      retrieve 'EmailSendDefinition',
+        UI_EMAIL_FIELDS + fields,
+        filter_by_folder(folder)
+    end
+
+    def folders(*fields)
+      data_folders 'email', *fields
+    end
+
+    def ui_folders(*fields)
+      data_folders 'userinitiated', *fields
+    end
+
+    def lists(*fields)
+      retrieve 'List', LIST_FIELDS + fields
+    end
+
+    def deliveries(*fields)
+      retrieve 'Send', DELIVERY_FIELDS + fields
+    end
+
+    private
+
+    def retrieve(type, fields, options={})
+      resources :retrieve, :retrieve_request => {
+        :object_type => type,
+        :properties => fields,
+        'ClientIDs' => { 'ID' => server.account }
+      }.merge(options)
+    end
+
+    def data_folders(type, *fields)
+      retrieve 'DataFolder', FOLDER_FIELDS + fields, filter_folders(type)
+    end
+
+    def filter_folders(type)
+      server.filter 'ContentType', 'like', type
+    end
+
+    def filter_email_like(name)
+      server.filter 'Name', 'like', name
+    end
+
+    def filter_by_folder(id)
+      server.filter 'CategoryID', 'equals', id
+    end
+  end
+end

data/lib/cupid/schedule.rb

@@ -0,0 +1,58 @@
+class Cupid
+  module Schedule
+
+    def schedule(ui, time, options={})
+      resource :schedule, :action => 'start',
+        :options => schedule_options,
+        :schedule => schedule_fields(time.iso8601, options),
+        :interactions => interactions_fields(ui.customer_key)
+    end
+
+    private
+
+    def schedule_fields(time, options)
+      {
+        :recurrence => {
+          :daily_recurrence_pattern_type => 'Interval',
+          :day_interval => 1
+        },
+        :attributes! => {
+          :recurrence => {
+            'xsi:type' => 'DailyRecurrence'
+          }
+        },
+        :recurrence_type => 'Daily',
+        :recurrence_range_type => 'EndAfter',
+        :start_date_time => time,
+        :occurrences => 1
+      }.merge options
+    end
+
+    def schedule_options
+      {
+        :client => {
+          'ID' => server.account
+        },
+        :attributes! => {
+          :client => {
+            'xsi:type' => 'ClientID'
+          }
+        }
+      }
+    end
+
+    def interactions_fields(ui_key)
+      {
+        :interaction => {
+          :customer_key => ui_key
+        },
+        :attributes! => {
+          :interaction => {
+            'xsi:type' => 'EmailSendDefinition'
+          }
+        }
+      }
+    end
+
+  end
+end

data/lib/cupid/server.rb

@@ -0,0 +1,62 @@
+class Cupid
+  class Server
+    INPUT_NAMES = {
+      :version_info       => 'VersionInfoRequestMsg',
+      :get_system_status  => 'SystemStatusRequestMsg',
+      :retrieve           => 'RetrieveRequestMsg',
+      :schedule           => 'ScheduleRequestMsg',
+      :create             => 'CreateRequest',
+      :delete             => 'DeleteRequest',
+      :update             => 'UpdateRequest'
+    }
+
+    attr_reader :account
+
+    def initialize(account)
+      @account = account
+    end
+
+    def input(action)
+      [INPUT_NAMES.fetch(action), { :xmlns => Cupid::NAMESPACE }]
+    end
+
+    def filter(field, operator, value)
+      return {} unless value
+      {
+        :filter => {
+          :property => field,
+          :simple_operator => operator,
+          :value => value
+        },
+        :attributes! => {
+          :filter => { 'xsi:type' => 'SimpleFilterPart' }
+        }
+      }
+    end
+
+    def objects(type, objects)
+      {
+        :objects => objects.map {|object|
+          {
+            :client => { 'ID' => account },
+          }.merge(object)
+        },
+        :attributes! => {
+          :objects => { 'xsi:type' => type }
+        }
+      }
+    end
+
+    def object(type, options)
+      objects type, [options]
+    end
+
+    def emails(ids)
+      objects 'Email', ids.map {|it| { 'ID' => it }}
+    end
+
+    def folders(ids)
+      objects 'DataFolder', ids.map {|it| { 'ID' => it }}
+    end
+  end
+end

data/lib/cupid/update.rb

@@ -0,0 +1,15 @@
+class Cupid
+  module Update
+    def ui_set_email(ui, email)
+      resource :update, ui_data(ui, email)
+    end
+
+    private
+
+    def ui_data(ui, email)
+      server.object 'EmailSendDefinition',
+        :customer_key => ui.customer_key,
+        :email => { 'ID' => email }
+    end
+  end
+end

data/lib/cupid/version.rb

@@ -1,3 +1,3 @@
-module Cupid
-  VERSION = '0.2.4'
+class Cupid
+  VERSION = "0.3.2"
 end

data/spec/cupid/create_spec.rb

@@ -0,0 +1,48 @@
+describe Cupid::Create do
+  subject { Cupid::Test }
+
+  def uniq_name(label)
+    "#{label} #{Time.now.to_i}"
+  end
+
+  shared_examples_for :creation do
+    it { creation.should be }
+    it { expect { creation }.to change { subject.send(items).size }.by 1 }
+  end
+
+  context '#create_folder' do
+    let(:parent)    { subject.folders.first }
+    let(:name)      { uniq_name :folder }
+    let(:items)     { :folders }
+    let(:creation)  { subject.create_folder name, parent }
+
+    it_should_behave_like :creation
+  end
+
+  context '#create_email' do
+    let(:name)      { uniq_name :subject }
+    let(:items)     { :emails }
+    let(:creation)  { subject.create_email name, :body }
+
+    it_should_behave_like :creation
+  end
+
+  context '#create_delivery' do
+    let(:email)     { subject.emails.last }
+    let(:list)      { subject.lists.find {|it| it[:list_name] == 'Test send' }}
+    let(:items)     { :deliveries }
+    let(:creation)  { subject.create_delivery email, list }
+
+    it_should_behave_like :creation
+  end
+
+  context '#create_path' do
+    let(:new_folders) {['my emails', Time.now.to_i, 'level2', 'level3']}
+
+    it do
+      expect {
+        subject.create_path *new_folders
+      }.to change { subject.folders.size }.by new_folders.size - 1
+    end
+  end
+end

data/spec/cupid/delete_spec.rb

@@ -0,0 +1,21 @@
+describe Cupid::Delete do
+  subject { Cupid::Test }
+
+  shared_examples_for 'deletion' do
+    let(:email) { subject.create_email email_name, 'body' }
+    let(:email_name) { 'subject' }
+
+    it { deletion.should be }
+    it { subject.emails.should_not include(email) }
+  end
+
+  context '#delete_emails' do
+    let(:deletion) { subject.delete_emails email }
+    it_should_behave_like 'deletion'
+  end
+
+  context '#delete_emails_like' do
+    let(:deletion) { subject.delete_emails_like email_name }
+    it_should_behave_like 'deletion'
+  end
+end

data/spec/cupid/response/caster_spec.rb

@@ -0,0 +1,19 @@
+describe Cupid::Response::Caster, '.create' do
+  subject { described_class.create :type => type }
+  Cupid::Response::SomeType = Class.new Cupid::Response::Object
+
+  context 'no type' do
+    let(:type) { nil }
+    it { should be_a Cupid::Response::Object }
+  end
+
+  context 'type without class' do
+    let(:type) { :type_without_class }
+    it { should be_a Cupid::Response::Object }
+  end
+
+  context 'type with class' do
+    let(:type) { :some_type }
+    it { should be_a Cupid::Response::SomeType }
+  end
+end

data/spec/cupid/response/data_spec.rb

@@ -0,0 +1,51 @@
+describe Cupid::Response::Data do
+  subject { described_class.from response }
+
+  let(:response) {{
+    :body => {
+      :overall_status => status,
+      :results => result
+    }
+  }}
+
+  describe 'unsuccessful response' do
+    let(:status) { 'some error' }
+
+    shared_examples_for 'response error' do
+      it { expect { subject }.to raise_exception described_class::Error, error_text }
+    end
+
+    context 'with status message' do
+      let(:result) {{ :status_message => error_text }}
+      let(:error_text) { 'bad_request' }
+
+      it_should_behave_like 'response error'
+    end
+
+    context 'without status message' do
+      let(:result) { nil }
+      let(:error_text) { status }
+
+      it_should_behave_like 'response error'
+    end
+  end
+
+  describe 'successful reponse' do
+    let(:status) { 'OK' }
+
+    context 'without results' do
+      let(:result) { nil }
+      it { should == [] }
+    end
+
+    context 'with one result' do
+      let(:result) {{ :field => :value }}
+      it { should == [{ :field => :value }] }
+    end
+
+    context 'with multiple results' do
+      let(:result) { [:object1, :object2] }
+      it { should == [:object1, :object2] }
+    end
+  end
+end