dotmailer 0.0.3 → 0.0.4

data/lib/dot_mailer/client.rb

@@ -73,6 +73,13 @@ module DotMailer
       end
     end
 
+    def delete(path)
+      rescue_api_errors do
+        endpoint = endpoint_for(path)
+        RestClient.delete endpoint, :accept => :json
+      end
+    end
+
     def to_s
       "#{self.class.name} api_user: #{api_user}"
     end

data/lib/dot_mailer/contact.rb

@@ -104,6 +104,10 @@ module DotMailer
       client.put_json "/contacts/#{id}", attributes.merge('dataFields' => data_fields_for_api)
     end
 
+    def delete
+      client.delete "/contacts/#{id}"
+    end
+
     def subscribed?
       status == SUBSCRIBED_STATUS
     end

data/lib/dot_mailer/contact_import.rb

@@ -2,11 +2,15 @@ require 'csv'
 require 'active_support/core_ext/object/blank'
 
 module DotMailer
+  # This is the maximum number of times we will poll the dotMailer
+  # API to see if an import has finished.
+  MAX_TRIES = 10
+
   class ContactImport
-    def self.import(account, contacts)
+    def self.import(account, contacts, wait_for_finish = false)
       contact_import = new(account, contacts)
 
-      contact_import.start
+      contact_import.start(wait_for_finish)
 
       contact_import
     end
@@ -18,12 +22,14 @@ module DotMailer
       self.contacts = contacts
     end
 
-    def start
+    def start(wait_for_finish)
       validate_headers
 
       response = client.post_csv '/contacts/import', contacts_csv
 
       self.id = response['id']
+
+      wait_until_finished if wait_for_finish
     end
 
     def status
@@ -90,5 +96,17 @@ module DotMailer
     def valid_headers
       @valid_headers ||= %w(id email optInType emailType) + account.data_fields.map(&:name)
     end
+
+    def wait_until_finished
+      # Wait for the import to finish, backing off in incremental powers
+      # of 2, a maximum of MAX_TRIES times.
+      #
+      # (i.e. 1s, 4s, 9s, 16s, ..., MAX_TRIES ** 2)
+      #
+      # A MAX_TRIES of 10 means we will wait a total of 385 seconds before
+      # giving up.
+      finished = (1..MAX_TRIES).detect { |i| sleep(i ** 2) && finished? }
+      raise ImportNotFinished unless finished
+    end
   end
 end

data/lib/dot_mailer/exceptions.rb

@@ -1,7 +1,13 @@
 module DotMailer
+  class Exception < ::Exception
+  end
+
   class ImportNotFinished < Exception
   end
 
+  class InvalidFromAddress < Exception
+  end
+
   class InvalidRequest < Exception
   end
 

data/lib/dot_mailer/from_address.rb

@@ -0,0 +1,36 @@
+require 'active_support/core_ext/hash/slice'
+
+module DotMailer
+  class FromAddress
+    def initialize(attributes)
+      self.attributes = attributes
+    end
+
+    def id
+      attributes['id']
+    end
+
+    def email
+      attributes['email']
+    end
+
+    def to_hash
+      attributes.slice('id', 'email')
+    end
+
+    def ==(other)
+      attributes == other.attributes
+    end
+
+    def to_s
+      %{#{self.class.name} id: #{id}, email: #{email}}
+    end
+
+    def inspect
+      to_s
+    end
+
+    protected
+    attr_accessor :attributes
+  end
+end

data/lib/dot_mailer/segment.rb

@@ -0,0 +1,36 @@
+module DotMailer
+  class Segment
+    def initialize(account, attributes)
+      self.account = account
+      self.attributes = attributes
+    end
+
+    def self.find_by_id(account, id)
+      response = account.client.get "/segments"
+      response = response.detect {|segment| segment['id'] == id}
+
+      new(account, response)
+    end
+
+    def id
+      attributes['id']
+    end
+
+    def refresh!
+      client.post_json "/segments/refresh/#{self.id}", {}
+    end
+
+    def refresh_progress
+      response = client.get "/segments/refresh/#{self.id}"
+      return response["status"]
+    end
+
+    private
+    attr_accessor :attributes, :account
+
+    def client
+      account.client
+    end
+  end
+end
+

data/lib/dot_mailer/version.rb

@@ -1,3 +1,3 @@
 module DotMailer
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/dot_mailer/account_spec.rb

@@ -4,11 +4,15 @@ describe DotMailer::Account do
   let(:api_user) { double 'api user' }
   let(:api_pass) { double 'api pass' }
   let(:client)   { double 'client' }
+  let(:cache)    { double 'cache' }
 
   subject { DotMailer::Account.new(api_user, api_pass) }
 
   before(:each) do
-    subject.stub :client => client
+    subject.stub(
+      :client => client,
+      :cache  => cache
+    )
   end
 
   describe '#initialize' do
@@ -51,11 +55,6 @@ describe DotMailer::Account do
 
   describe '#data_fields' do
     let(:data_fields) { double 'data fields' }
-    let(:cache)       { double 'cache' }
-
-    before(:each) do
-      subject.stub :cache => cache
-    end
 
     context 'when the cache is empty' do
       before(:each) do
@@ -90,10 +89,8 @@ describe DotMailer::Account do
   describe '#create_data_field' do
     let(:name)    { double 'name' }
     let(:options) { double 'options' }
-    let(:cache)   { double 'cache' }
 
     before(:each) do
-      subject.stub :cache => cache
       DotMailer::DataField.stub :create
       cache.stub :delete
     end
@@ -110,4 +107,56 @@ describe DotMailer::Account do
       subject.create_data_field(name, options)
     end
   end
+
+  describe '#from_addresses' do
+    let(:attributes)     { double 'attributes' }
+    let(:response)       { 3.times.map { attributes } }
+    let(:from_address)   { double 'from address' }
+    let(:from_addresses) { 3.times.map { from_address } }
+
+    before(:each) do
+      DotMailer::FromAddress.stub :new => from_address
+    end
+
+    context 'when the cache is empty' do
+      before(:each) do
+        cache.stub(:fetch).with('from_addresses').and_yield
+        client.stub :get => response
+      end
+
+      it 'should call get on the client with the correct path' do
+        client.should_receive(:get).with('/custom-from-addresses')
+
+        subject.from_addresses
+      end
+
+      it 'should initialize 3 FromAddresses' do
+        DotMailer::FromAddress.should_receive(:new).with(attributes).exactly(3).times
+
+        subject.from_addresses
+      end
+
+      its(:from_addresses) { should == from_addresses }
+    end
+
+    context 'when the cache is not empty' do
+      before(:each) do
+        cache.stub(:fetch).with('from_addresses').and_return(response)
+      end
+
+      it 'should not call get on the client' do
+        client.should_not_receive(:get)
+
+        subject.from_addresses
+      end
+
+      it 'should initialize 3 FromAddresses' do
+        DotMailer::FromAddress.should_receive(:new).with(attributes).exactly(3).times
+
+        subject.from_addresses
+      end
+
+      its(:from_addresses) { should == from_addresses }
+    end
+  end
 end

data/spec/dot_mailer/campaign_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+describe DotMailer::Campaign do
+  let(:client)  { double 'client' }
+  let(:account) { double 'account', :client => client }
+
+  let(:id)                 { 123 }
+  let(:name)               { 'my_campaign' }
+  let(:campaign_subject)   { 'My Campaign' }
+  let(:from_name)          { 'Me' }
+  let(:from_email)         { 'me@example.com' }
+  let(:html_content)       { '<h1>Hello!</h1><a href="http://$UNSUB$">Unsubscribe</a>' }
+  let(:plain_text_content) { "Hello!\n======\nhttp://$UNSUB$" }
+
+  let(:from_address) do
+    DotMailer::FromAddress.new 'id' => 123, 'email' => from_email
+  end
+
+  subject do
+    DotMailer::Campaign.new(account, {
+      'id'               => id,
+      'name'             => name,
+      'subject'          => campaign_subject,
+      'fromName'         => from_name,
+      'fromAddress'      => from_address.to_hash,
+      'htmlContent'      => html_content,
+      'plainTextContent' => plain_text_content
+    })
+  end
+
+  describe 'Class' do
+    subject { DotMailer::Campaign }
+
+    describe '.create' do
+      let(:response) { double 'response' }
+      let(:campaign) { double 'campaign' }
+
+      # We define a method so we can override keys within
+      # context blocks without redefining other keys
+      def attributes
+        {
+          :name               => name,
+          :subject            => campaign_subject,
+          :from_name          => from_name,
+          :from_email         => from_email,
+          :html_content       => html_content,
+          :plain_text_content => plain_text_content
+        }
+      end
+
+      before(:each) do
+        account.stub :from_addresses => [from_address]
+        client.stub :post_json => response
+        subject.stub :new => campaign
+      end
+
+      [
+        :name,
+        :subject,
+        :from_name,
+        :from_email,
+        :html_content,
+        :plain_text_content
+      ].each do |attribute|
+        context "without specifying #{attribute}" do
+          define_method :attributes do
+            super().except(attribute)
+          end
+
+          it 'should raise an error' do
+            expect { subject.create(account, attributes) }.to \
+              raise_error(RuntimeError, "missing :#{attribute}")
+          end
+        end
+      end
+
+      context 'when the fromAddress is not a valid from address' do
+        let(:unknown_email) { 'unknown@example.com' }
+
+        def attributes
+          super.merge(:from_email => unknown_email)
+        end
+
+        it 'should raise an error' do
+          expect { subject.create(account, attributes) }.to \
+            raise_error(DotMailer::InvalidFromAddress, unknown_email)
+        end
+      end
+
+      it 'should call post_json on the client with the correct path' do
+        client.should_receive(:post_json).with('/campaigns', anything)
+
+        subject.create(account, attributes)
+      end
+
+      it 'should call post_json on the client with the correct parameters' do
+        client.should_receive(:post_json).with(anything, {
+          'Name'             => name,
+          'Subject'          => campaign_subject,
+          'FromName'         => from_name,
+          'FromAddress'      => from_address.to_hash,
+          'HtmlContent'      => html_content,
+          'PlainTextContent' => plain_text_content
+        })
+
+        subject.create(account, attributes)
+      end
+
+      it 'should instantiate a new Campaign object with the account and response' do
+        subject.should_receive(:new).with(account, response)
+
+        subject.create(account, attributes)
+      end
+
+      it 'should return the new Campaign object' do
+        subject.create(account, attributes).should == campaign
+      end
+    end
+
+    describe '.find_by_id' do
+      let(:id)       { 123 }
+      let(:response) { double 'response' }
+      let(:campaign) { double 'campaign' }
+
+      before(:each) do
+        subject.stub :new => campaign
+        client.stub :get => response
+      end
+
+      it 'should call get on the client with the correct parameters' do
+        client.should_receive(:get).with("/campaigns/#{id}")
+
+        subject.find_by_id(account, id)
+      end
+
+      it 'should initialize a Campaign with the response' do
+        subject.should_receive(:new).with(account, response)
+
+        subject.find_by_id(account, id)
+      end
+
+      it 'should return the new Campaign object' do
+        subject.find_by_id(account, id).should == campaign
+      end
+    end
+  end
+
+  its(:id)                 { should == id }
+  its(:name)               { should == name }
+  its(:from_name)          { should == from_name }
+  its(:from_address)       { should == from_address }
+  its(:html_content)       { should == html_content }
+  its(:plain_text_content) { should == plain_text_content }
+
+  describe '#send_to_contact_ids' do
+    let(:contact_ids) { double 'contact ids' }
+
+    it 'should call post_json on the client with the correct path' do
+      client.should_receive(:post_json).with('/campaigns/send', anything)
+
+      subject.send_to_contact_ids contact_ids
+    end
+
+    it 'should call post_json on the client with the contact ids' do
+      client.should_receive(:post_json).with(anything, {
+        'campaignId' => id,
+        'contactIds' => contact_ids
+      })
+
+      subject.send_to_contact_ids contact_ids
+    end
+  end
+
+  describe '#send_to_segment' do
+    let(:segment) { double 'segment', :id => 123 }
+
+    it 'should call post_json on the client with the correct path' do
+      client.should_receive(:post_json).with('/campaigns/send', anything)
+
+      subject.send_to_segment segment
+    end
+
+    it 'should call post_json on the client with the contact ids' do
+      client.should_receive(:post_json).with(anything, {
+        'campaignId' => id,
+        'addressBookIds' => [segment.id]
+      })
+
+      subject.send_to_segment segment
+    end
+  end
+
+  describe '#summary' do
+    let(:summary) { double 'campaign_summary'}
+
+    it 'should call get on the client with the correct path' do
+      client.should_receive(:get).with("/campaigns/#{id}/summary")
+      subject.summary
+    end
+
+    it 'should return a CampaignSummary object' do
+      client.should_receive(:get).with(anything).and_return(summary)
+      subject.summary.class.should be(DotMailer::CampaignSummary)
+    end
+  end
+end