govdelivery-tms 0.8.0

data/lib/govdelivery-tms/resource/webhook.rb

@@ -0,0 +1,20 @@
+module TMS #:nodoc:
+  #  A Webhook gets invoked when a recipient enters a queued or final state
+  #
+  # @attr url [String] The URL to POST webhooks to
+  # @attr event_type  'sending', 'inconclusive', 'blacklisted', 'sent', 'canceled', or 'failed'
+  #
+  # @example
+  #    webhook = client.webhooks.build(:url => 'http://your.url', :event_type => 'failed')
+  #    webhook.post
+  #    webhook.get
+  class Webhook
+    include InstanceResource
+
+    # @!parse attr_accessor :url, :event_type
+    writeable_attributes :url, :event_type
+
+    # @!parse attr_reader :created_at, :updated_at
+    readonly_attributes :created_at, :updated_at
+  end
+end

data/lib/govdelivery-tms/util/core_ext.rb

@@ -0,0 +1,27 @@
+require 'active_support/inflector'
+
+module TMS::CoreExt
+  def demodulize(path)
+    ActiveSupport::Inflector.demodulize(path)
+  end
+
+  def classify(str)
+    ActiveSupport::Inflector.camelize(str)
+  end
+
+  def singularize(str)
+      ActiveSupport::Inflector.singularize(str)
+    end
+
+  def pluralize(str)
+    ActiveSupport::Inflector.pluralize(str)
+  end
+
+  def tmsify(klassname)
+    ActiveSupport::Inflector.underscore(demodulize(klassname))
+  end
+
+  def instance_class(klass)
+    ActiveSupport::Inflector.constantize(singularize(klass.to_s))
+  end
+end

data/lib/govdelivery-tms/util/hal_link_parser.rb

@@ -0,0 +1,50 @@
+module TMS::Util
+  module HalLinkParser
+
+    def parse_links(_links)
+      @resources = {}
+      return if _links.nil?
+      parse_link(_links) and return if _links.is_a?(Hash)
+      _links.each { |link| parse_link(link) }
+    end
+
+    def subresources
+      @resources
+    end
+
+    protected
+
+    def metaclass
+      @metaclass ||= class << self;
+        self;
+      end
+    end
+
+    def parse_link(link)
+      link.each do |rel, href|
+        if rel == 'self'
+          self.href = href
+        else
+          klass = relation_class(rel)
+          klass = self.class if ['first', 'prev', 'next', 'last'].include?(rel)
+          if klass
+            subresources[rel] = klass.new(self.client, href)
+            setup_subresource(link)
+          else
+            logger.info("Don't know what to do with link rel '#{rel}' for class #{self.class.to_s}!") if self.respond_to?(:logger)
+          end
+
+        end
+      end
+    end
+
+    def relation_class(rel)
+      ::TMS.const_get(classify(rel)) rescue nil
+    end
+
+    def setup_subresource(link)
+      return unless link
+      link.each { |rel, href| self.metaclass.send(:define_method, rel.to_sym, &lambda { subresources[rel] }) unless rel == 'self' }
+    end
+  end
+end

data/lib/govdelivery-tms/version.rb

@@ -0,0 +1,3 @@
+module TMS #:nodoc:
+  VERSION = "0.8.0"
+end

data/spec/client_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+describe TMS::Client do
+  context "creating a new client" do
+    before do
+      response = double('response', :status => 200, :body => {"_links" => [{"self" => "/"}, {"horse" => "/horses/new"}, {"rabbits" => "/rabbits"}]})
+      @raw_connection = double('raw_connection', :get => response)
+      @connection = TMS::Connection.stub(:new).and_return(double('connection', :connection => @raw_connection))
+      @client = TMS::Client.new('auth_token', :api_root => 'null_url')
+    end
+    it 'should set up logging' do
+      @client.logger.should_not be_nil
+      @client.logger.level.should eq(Logger::INFO)
+    end
+    it 'should discover endpoints for known services' do
+      @client.horse.should be_kind_of(TMS::Horse)
+      @client.rabbits.should be_kind_of(TMS::Rabbits)
+    end
+    it 'should handle 4xx responses' do
+      @raw_connection.stub(:get).and_return(double('response', :status => 404, :body => {'message' => 'hi'}))
+      expect { @client.get('/blargh') }.to raise_error(TMS::Request::Error)
+    end
+    it 'should handle 5xx responses' do
+      @raw_connection.stub(:get).and_return(double('response', :status => 503, :body => {'message' => 'oops'}))
+      expect { @client.get('/blargh') }.to raise_error(TMS::Request::Error)
+    end
+    it 'should handle 202 responses' do
+      @raw_connection.stub(:get).and_return(double('response', :status => 202, :body => {'message' => 'hi'}))
+      expect { @client.get('/blargh') }.to raise_error(TMS::Request::InProgress)
+    end
+
+    context 'creating a new client without output' do
+      subject { TMS::Client.new('auth_token', api_root: 'null_url', logger: false) }
+      its(:logger){ should be_falsey }
+      its(:horse) { should be_kind_of(TMS::Horse) }
+    end
+
+    it 'defaults to the public API URL' do
+      expect(TMS::Client.new('auth_token').api_root).to eq('https://tms.govdelivery.com')
+    end
+  end
+end

data/spec/command_types_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe TMS::CommandTypes do
+  context "loading command types" do
+    let(:client) do
+      double('client')
+    end
+    before do
+      @command_types = TMS::CommandTypes.new(client, '/command_types')
+    end
+    it 'should GET ok' do
+      body = [{"name"=>"dcm_unsubscribe",
+               "string_fields"=>[],
+               "array_fields"=>["dcm_account_codes"]},
+              {"name"=>"dcm_subscribe",
+               "string_fields"=>["dcm_account_code"],
+               "array_fields"=>["dcm_topic_codes"]},
+              {"name"=>"forward",
+               "string_fields"=>["http_method", "username", "password", "url"],
+               "array_fields"=>[]}] 
+      @command_types.client.should_receive(:get).and_return(double('response', :body => body, :status => 200, :headers => {}))
+      @command_types.get
+      @command_types.collection.length.should == 3
+      ct = @command_types.collection.find{|c| c.name == "dcm_subscribe"}
+      ct.array_fields.should eq(["dcm_topic_codes"])
+      ct.string_fields.should eq(["dcm_account_code"])
+    end
+  end
+end

data/spec/email_message_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe TMS::EmailMessage do
+  context "creating a new message" do
+    let(:client) do
+      double('client')
+    end
+    before do
+      @message = TMS::EmailMessage.new(client, '/messages/email', {
+        :body       => '12345678',
+        :subject    => 'blah',
+        :created_at => 'BAAAAAD',
+        :from_email => 'eric@evotest.govdelivery.com',
+        :errors_to  => 'errors@evotest.govdelivery.com',
+        :reply_to   => 'replyto@evotest.govdelivery.com'})
+    end
+    it 'should not render readonly attrs in json hash' do
+      @message.to_json[:body].should == '12345678'
+      @message.to_json[:created_at].should == nil
+    end
+    it 'should initialize with attrs and collections' do
+      @message.body.should             == '12345678'
+      @message.subject.should          == 'blah'
+      @message.from_email.should       == 'eric@evotest.govdelivery.com'
+      @message.reply_to.should         == 'replyto@evotest.govdelivery.com'
+      @message.errors_to.should        == 'errors@evotest.govdelivery.com'
+      @message.recipients.class.should == TMS::EmailRecipients
+    end
+    it 'should post successfully' do
+      response = {
+          :body       => 'processed',
+          :subject    => 'blah',
+          :from_email => 'eric@evotest.govdelivery.com',
+          :errors_to  => 'errors@evotest.govdelivery.com',
+          :reply_to   => 'replyto@evotest.govdelivery.com',
+          :recipients => [{:email => 'billy@evotest.govdelivery.com'}],
+          :failed => [{:email => 'billy@evotest.govdelivery.com'}],
+          :sent => [{:email => 'billy@evotest.govdelivery.com'}],
+          :created_at => 'time'
+      }
+      @message.client.should_receive('post').with(@message).and_return(double('response', :status => 201, :body => response))
+      @message.post
+      @message.body.should                              == 'processed'
+      @message.created_at.should                        == 'time'
+      @message.from_email.should                        == 'eric@evotest.govdelivery.com'
+      @message.reply_to.should                          == 'replyto@evotest.govdelivery.com'
+      @message.errors_to.should                         == 'errors@evotest.govdelivery.com'
+      @message.recipients.class.should                  == TMS::EmailRecipients
+      @message.recipients.collection.first.class.should == TMS::EmailRecipient
+      @message.sent.class.should == TMS::EmailRecipients
+      @message.sent.collection.first.class.should == TMS::EmailRecipient
+      @message.failed.class.should == TMS::EmailRecipients
+      @message.failed.collection.first.class.should == TMS::EmailRecipient
+    end
+    it 'should handle errors' do
+      response = {'errors' => {:body => "can't be nil"}}
+      @message.client.should_receive('post').with(@message).and_return(double('response', :status => 422, :body => response))
+      @message.post
+      @message.body.should == '12345678'
+      @message.errors.should == {:body => "can't be nil"}
+    end
+
+    it 'should handle 401 errors' do
+      @message.client.should_receive('post').with(@message).and_return(double('response', :status => 401))
+      expect {@message.post}.to raise_error(StandardError, "401 Not Authorized")
+    end
+
+    it 'should handle 404 errors' do
+      @message.client.should_receive('post').with(@message).and_return(double('response', :status => 404))
+      expect {@message.post}.to raise_error(StandardError, "Can't POST to /messages/email")
+    end
+  end
+
+  context 'an existing message' do
+    let(:client) do
+      double('client')
+    end
+    before do
+      # blank hash prevents the client from doing a GET in the initialize method
+      @message = TMS::EmailMessage.new(client, '/messages/99', {})
+    end
+    it 'should GET cleanly' do
+      response = {:body => 'processed',
+                  :subject    => 'hey',
+                  :from_email => 'eric@evotest.govdelivery.com',
+                  :errors_to  => 'errors@evotest.govdelivery.com',
+                  :reply_to   => 'replyto@evotest.govdelivery.com',
+                  :recipients => [{:email => 'billy@evotest.govdelivery.com'}],
+                  :created_at => 'time'}
+      @message.client.should_receive('get').with(@message.href).and_return(double('response', :status => 200, :body => response))
+      @message.get
+      @message.body.should       == 'processed'
+      @message.subject.should    == 'hey'
+      @message.from_email.should == 'eric@evotest.govdelivery.com'
+      @message.reply_to.should   == 'replyto@evotest.govdelivery.com'
+      @message.errors_to.should  == 'errors@evotest.govdelivery.com'
+      @message.created_at.should == 'time'
+    end
+  end
+
+
+end

data/spec/email_template_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe TMS::EmailTemplate do
+  context "creating a list of email templates" do
+    let(:client) do
+      double('client')
+    end
+    before do
+      @templates = TMS::EmailTemplates.new(client, '/templates/email')
+    end
+
+    it 'should be able to get a list of email templates' do
+      response = [
+        {
+        'id'                         => "1",
+        'body'                       => "Template 1",
+        'subject'                    => "This is the template 1 subject",
+        'link_tracking_parameters'   => "test=ok&hello=world",
+        'macros'                     => {"MACRO1" => "1"},
+        'open_tracking_enabled'      => true,
+        'click_tracking_enabled'     => true,
+        'created_at'                 => "sometime",
+        '_links'                     => {"self" => "/templates/email/1","account" => "/accounts/1","from_address" => "/from_addresses/1"}
+        }
+      ]
+
+      @templates.client.should_receive('get').with('/templates/email').and_return(double('response', :status => 200, :body => response, :headers => {}))
+      @templates.get
+      @templates.collection.length.should == 1
+    end
+  end
+
+  context "creating an email template" do
+    let(:client) do
+      double('client')
+    end
+    before do
+      @template = TMS::EmailTemplate.new(client, '/templates/email', {
+        :body                       => "Template 1",
+        :subject                    => "This is the template 1 subject",
+        :link_tracking_parameters   => "test=ok&hello=world",
+        :macros                     => {"MACRO1" => "1"},
+        :open_tracking_enabled      => true,
+        :click_tracking_enabled     => true,
+      })
+    end
+
+    it 'should render linkable attrs in json hash' do
+      @template.links[:from_address] = "1"
+      @template.links[:invalid] = "2"
+      links = @template.to_json[:_links]
+      links[:from_address].should == '1'
+      links[:invalid].should be_nil
+    end
+
+    it 'should clear the links property after a successful post' do
+      @template.links[:from_address] = "1"
+      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 201, :body => {}))
+      @template.post
+      links = @template.to_json[:_links]
+      links[:from_address].should be_nil
+    end
+
+    it 'should not clear the links property after an invalid post' do
+      @template.links[:from_address] = "1"
+      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 400, :body => {}))
+      @template.post
+      links = @template.to_json[:_links]
+      links[:from_address].should == "1"
+    end
+
+    it 'should post successfully' do
+      response = {
+        'id'                         => "1",
+        'body'                       => "Template 1",
+        'subject'                    => "This is the template 1 subject",
+        'link_tracking_parameters'   => "test=ok&hello=world",
+        'macros'                     => {"MACRO1" => "1"},
+        'open_tracking_enabled'      => true,
+        'click_tracking_enabled'     => true,
+        'created_at'                 => "sometime",
+        '_links'                     => {"self" => "/templates/email/1","account" => "/accounts/1","from_address" => "/from_addresses/1"}
+      }
+      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 201, :body => response))
+      @template.post
+      @template.id.should                                == '1'
+      @template.body.should                              == 'Template 1'
+      @template.subject.should                           == 'This is the template 1 subject'
+      @template.link_tracking_parameters.should          == 'test=ok&hello=world'
+      @template.macros.should                            == {"MACRO1"=>"1"}
+      @template.open_tracking_enabled.should             == true
+      @template.click_tracking_enabled.should            == true
+      @template.created_at.should                        == 'sometime'
+      @template.from_address.should                      be_a(TMS::FromAddress)
+    end
+  end
+
+  context "handling errors at the template level" do
+    let(:client) do
+      double('client')
+    end
+    before do
+      @template = TMS::EmailTemplate.new(client, '/templates/email/1')
+    end
+
+    it 'should handle errors' do
+      response = {'errors' => {:body => "can't be nil"}}
+      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 422, :body => response))
+      @template.post
+      @template.errors.should == {:body => "can't be nil"}
+    end
+
+    it 'should handle 401 errors' do
+      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 401))
+      expect {@template.post}.to raise_error("401 Not Authorized")
+    end
+
+    it 'should handle 404 errors' do
+      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 404))
+      expect {@template.post}.to raise_error("Can't POST to /templates/email/1")
+    end
+  end
+
+  context "handling errors at the email_templates root level" do
+    let(:client) do
+      double('client')
+    end
+    before do
+      @template = TMS::EmailTemplate.new(client, '/templates/email')
+    end
+
+    it 'should handle errors' do
+      response = {'errors' => {:body => "can't be nil"}}
+      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 422, :body => response))
+      @template.post
+      @template.errors.should == {:body => "can't be nil"}
+    end
+
+    it 'should handle 401 errors' do
+      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 401))
+      expect {@template.post}.to raise_error("401 Not Authorized")
+    end
+
+    it 'should handle 404 errors' do
+      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 404))
+      expect {@template.post}.to raise_error("Can't POST to /templates/email")
+    end
+  end
+end

data/spec/errors_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe TMS::Errors do
+  context "an errors hash" do
+    let(:object_with_errors) do
+      double('instance', href: 'href', errors: {"body" => ["can't be blank"], "subject" => ["can't be blank"]})
+    end
+    subject { TMS::Errors::InvalidVerb.new(object_with_errors) }
+    it 'should work' do
+      subject.message.should =~ /body can't be blank, subject can't be blank/
+    end
+  end
+end