dotmailer 0.0.1 → 0.0.2

data/lib/dot_mailer/contact_import.rb

@@ -0,0 +1,94 @@
+require 'csv'
+require 'active_support/core_ext/object/blank'
+
+module DotMailer
+  class ContactImport
+    def self.import(account, contacts)
+      contact_import = new(account, contacts)
+
+      contact_import.start
+
+      contact_import
+    end
+
+    attr_reader :id
+
+    def initialize(account, contacts)
+      self.account  = account
+      self.contacts = contacts
+    end
+
+    def start
+      validate_headers
+
+      response = client.post_csv '/contacts/import', contacts_csv
+
+      self.id = response['id']
+    end
+
+    def status
+      if id.nil?
+        'NotStarted'
+      else
+        response = client.get "/contacts/import/#{id}"
+
+        response['status']
+      end
+    end
+
+    def finished?
+      status == 'Finished'
+    end
+
+    def errors
+      raise ImportNotFinished unless finished?
+
+      client.get_csv "/contacts/import/#{id}/report-faults"
+    end
+
+    def to_s
+      "#{self.class.name} contacts: #{contacts.to_s}"
+    end
+
+    def inspect
+      to_s
+    end
+
+    private
+    attr_accessor :contacts, :account
+    attr_writer :id
+
+    def client
+      account.client
+    end
+
+    def contact_headers
+      @contact_headers ||= contacts.map(&:keys).flatten.uniq
+    end
+
+    def contacts_csv
+      @contacts_csv ||= CSV.generate do |csv|
+        csv << contact_headers
+
+        contacts.each do |contact|
+          csv << contact_headers.map { |header| contact[header] }
+        end
+      end
+    end
+
+    # Check that the contact_headers are all valid (case insensitive)
+    def validate_headers
+      raise UnknownDataField, unknown_headers.join(',') if unknown_headers.present?
+    end
+
+    def unknown_headers
+      @unknown_headers ||= contact_headers.reject do |header|
+        valid_headers.map(&:downcase).include?(header.downcase)
+      end
+    end
+
+    def valid_headers
+      @valid_headers ||= %w(id email optInType emailType) + account.data_fields.map(&:name)
+    end
+  end
+end

data/lib/{dotmailer → dot_mailer}/data_field.rb

@@ -1,5 +1,24 @@
-module Dotmailer
+module DotMailer
   class DataField
+    def self.all(account)
+      fields = account.client.get '/data-fields'
+
+      fields.map { |attributes| new(attributes) }
+    end
+
+    def self.create(account, name, options = {})
+      options[:type]       ||= 'String'
+      options[:visibility] ||= 'Public'
+
+      account.client.post_json(
+        '/data-fields',
+        'name'         => name,
+        'type'         => options[:type],
+        'visibility'   => options[:visibility],
+        'defaultValue' => options[:default]
+      )
+    end
+
     def initialize(attributes)
       self.attributes = attributes
     end
@@ -32,6 +51,10 @@ module Dotmailer
       attributes == other.attributes
     end
 
+    def date?
+      type == 'Date'
+    end
+
     protected
     attr_accessor :attributes
   end

data/lib/dot_mailer/exceptions.rb

@@ -0,0 +1,16 @@
+module DotMailer
+  class ImportNotFinished < Exception
+  end
+
+  class InvalidRequest < Exception
+  end
+
+  class NotFound < Exception
+  end
+
+  class UnknownDataField < Exception
+  end
+
+  class UnknownOptInType < Exception
+  end
+end

data/lib/dot_mailer/opt_in_type.rb

@@ -0,0 +1,16 @@
+module DotMailer
+  module OptInType
+    DOUBLE          = 'Double'
+    SINGLE          = 'Single'
+    UNKNOWN         = 'Unknown'
+    VERIFIED_DOUBLE = 'VerifiedDouble'
+
+    def self.all
+      constants(false).map(&method(:const_get))
+    end
+
+    def self.exists?(opt_in_type)
+      all.include?(opt_in_type)
+    end
+  end
+end

data/lib/dot_mailer/suppression.rb

@@ -0,0 +1,29 @@
+require 'time'
+
+module DotMailer
+  class Suppression
+    attr_reader :contact, :date_removed, :reason
+
+    def self.suppressed_since(account, time)
+      response = account.client.get("/contacts/suppressed-since/#{time.utc.xmlschema}")
+
+      response.map do |attributes|
+        new(account, attributes)
+      end
+    end
+
+    def initialize(account, attributes)
+      @contact      = Contact.new account, attributes['suppressedContact']
+      @date_removed = Time.parse attributes['dateRemoved']
+      @reason       = attributes['reason']
+    end
+
+    def to_s
+      %{#{self.class.name} reason: #{reason}, date_removed: #{date_removed}, contact: #{contact.to_s}}
+    end
+
+    def inspect
+      to_s
+    end
+  end
+end

data/lib/dot_mailer/version.rb

@@ -0,0 +1,3 @@
+module DotMailer
+  VERSION = "0.0.2"
+end

data/lib/dotmailer.rb

@@ -1,3 +1 @@
-require 'dotmailer/exceptions'
-require 'dotmailer/data_field'
-require 'dotmailer/client'
+require 'dot_mailer'

data/spec/dot_mailer/account_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe DotMailer::Account do
+  let(:api_user) { double 'api user' }
+  let(:api_pass) { double 'api pass' }
+  let(:client)   { double 'client' }
+
+  subject { DotMailer::Account.new(api_user, api_pass) }
+
+  before(:each) do
+    subject.stub :client => client
+  end
+
+  describe '#initialize' do
+    before(:each) do
+      DotMailer::Client.stub :new => client
+    end
+
+    it 'should initialize a Client with the credentials' do
+      DotMailer::Client.should_receive(:new).with(api_user, api_pass)
+
+      DotMailer::Account.new(api_user, api_pass)
+    end
+
+    it 'should set the client' do
+      DotMailer::Client.should_receive(:new).with(api_user, api_pass)
+
+      account = DotMailer::Account.new(api_user, api_pass)
+    end
+  end
+
+  describe '#suppress' do
+    let(:email) { double 'email' }
+
+    before(:each) do
+      client.stub :post_json
+    end
+
+    it 'should call post_json on the client with the correct path' do
+      client.should_receive(:post_json).with('/contacts/unsubscribe', anything)
+
+      subject.suppress email
+    end
+
+    it 'should call post_json on the client with the email address' do
+      client.should_receive(:post_json).with(anything, 'Email' => email)
+
+      subject.suppress email
+    end
+  end
+
+  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
+        cache.stub(:fetch).with('data_fields').and_yield
+        DotMailer::DataField.stub :all => data_fields
+      end
+
+      it 'should call DataField.all' do
+        DotMailer::DataField.should_receive(:all).with(subject)
+
+        subject.data_fields
+      end
+
+      its(:data_fields) { should == data_fields }
+    end
+
+    context 'when the cache is not empty' do
+      before(:each) do
+        cache.stub(:fetch).with('data_fields').and_return(data_fields)
+      end
+
+      it 'should not call DataField.all' do
+        DotMailer::DataField.should_not_receive(:all)
+
+        subject.data_fields
+      end
+
+      its(:data_fields) { should == data_fields }
+    end
+  end
+
+  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
+
+    it 'should DataField.create' do
+      DotMailer::DataField.should_receive(:create).with(subject, name, options)
+
+      subject.create_data_field(name, options)
+    end
+
+    it 'should clear the data_fields from the cache' do
+      cache.should_receive(:delete).with('data_fields')
+
+      subject.create_data_field(name, options)
+    end
+  end
+end

data/spec/dot_mailer/client_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe DotMailer::Client do
+  let(:api_user)      { 'john_doe' }
+  let(:api_pass)      { 's3cr3t' }
+  let(:api_base_url)  { "https://#{api_user}:#{api_pass}@api.dotmailer.com" }
+  let(:api_path)      { '/some/api/path' }
+  let(:api_endpoint)  { "#{api_base_url}/v2#{api_path}" }
+
+  subject { DotMailer::Client.new(api_user, api_pass) }
+
+  describe '#get' do
+    let(:response) { { 'foo' => 'bar' } }
+
+    before(:each) do
+      stub_request(:get, api_endpoint).to_return(:body => response.to_json)
+    end
+
+    it 'should GET the endpoint with a JSON accept header' do
+      subject.get api_path
+
+      WebMock.should have_requested(:get, api_endpoint).with(
+        :headers => { 'Accept' => 'application/json' }
+      )
+    end
+
+    it 'should return the response from the endpoint' do
+      subject.get(api_path).should == response
+    end
+
+    context 'when the path is not found' do
+      let(:error_message) { 'not found' }
+      let(:response)      { { 'message' => error_message } }
+
+      before(:each) do
+        stub_request(:get, api_endpoint).to_return(:status => 404, :body => response.to_json)
+      end
+
+      it 'should raise a NotFound error with the error message' do
+        expect { subject.get(api_path).should }.to raise_error(DotMailer::NotFound, error_message)
+      end
+    end
+  end
+
+  describe '#get_csv' do
+    # The API includes a UTF-8 BOM in the response...
+    let(:response) { "\xEF\xBB\xBFId,Name\n1,Foo\n2,Bar" }
+    let(:csv)      { double 'csv' }
+
+    before(:each) do
+      stub_request(:get, api_endpoint).to_return(:body => response)
+      CSV.stub(:parse => csv)
+    end
+
+    it 'should GET the endpoint with a CSV accept header' do
+      subject.get_csv api_path
+
+      WebMock.should have_requested(:get, api_endpoint).with(
+        :headers => { 'Accept' => 'text/csv' }
+      )
+    end
+
+    it 'should pass the response to CSV.parse with the correct options' do
+      CSV.should_receive(:parse).with(response, :headers => true)
+
+      subject.get_csv api_path
+    end
+
+    it 'should return the CSV object' do
+      subject.get_csv(api_path).should == csv
+    end
+  end
+
+  describe '#post' do
+    let(:data)     { 'some random data' }
+    let(:response) { { 'foo' => 'bar' } }
+
+    before(:each) do
+      stub_request(:post, api_endpoint).to_return(:body => response.to_json)
+    end
+
+    it 'should POST the data to the endpoint with a JSON accept header' do
+      subject.post api_path, data
+
+      WebMock.should have_requested(:post, api_endpoint).with(
+        :headers => { 'Accept' => 'application/json' },
+        :body    => data
+      )
+    end
+
+    it 'should return the response from the endpoint' do
+      subject.post(api_path, data).should == response
+    end
+
+    context 'when the data is invalid for the endpoint' do
+      let(:error_message) { 'invalid data' }
+      let(:response)      { { 'message' => error_message } }
+
+      before(:each) do
+        stub_request(:post, api_endpoint).to_return(:status => 400, :body => response.to_json)
+      end
+
+      it 'should raise an InvalidRequest error with the error message' do
+        expect { subject.post(api_path, data) }.to raise_error(DotMailer::InvalidRequest, error_message)
+      end
+    end
+  end
+
+  describe '#post_json' do
+    let(:params) { { 'foo' => 'bar' } }
+
+    it 'should call post with the path' do
+      subject.should_receive(:post).with(api_path, anything, anything)
+
+      subject.post_json api_path, params
+    end
+
+    it 'should convert the params to JSON' do
+      subject.should_receive(:post).with(anything, params.to_json, anything)
+
+      subject.post_json api_path, params
+    end
+
+    it 'should pass use the correct content type' do
+      subject.should_receive(:post).with(anything, anything, hash_including(:content_type => :json))
+
+      subject.post_json api_path, params
+    end
+  end
+
+  describe '#post_csv' do
+    let(:csv)      { "Some\nCSV\nString" }
+    let(:tempfile) { double 'tempfile', :write => true, :rewind => true }
+
+    before(:each) do
+      Tempfile.stub :new => tempfile
+      subject.stub :post => double
+    end
+
+    it 'should call post with the path' do
+      subject.should_receive(:post).with(api_path, anything)
+
+      subject.post_csv api_path, csv
+    end
+
+    it 'should create a Tempfile with the contents and rewind it' do
+      Tempfile.should_receive(:new).and_return(tempfile)
+      tempfile.should_receive(:write).with(csv)
+      tempfile.should_receive(:rewind)
+
+      subject.post_csv api_path, csv
+    end
+
+    it 'should call post with the tempfile' do
+      subject.should_receive(:post).with(api_path, hash_including(:csv => tempfile))
+
+      subject.post_csv api_path, csv
+    end
+  end
+end