delighted 1.7.0 → 2.1.0rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 24e928b7535e1d51f72461238850e824b27b3920
-  data.tar.gz: 86001bae9ecc475902d0ce5f2d4ed1cc15d6f686
+SHA256:
+  metadata.gz: 3ce86b0edf1b9df5dab8e46ba0fc4213c6c14667b7a4fe28d441e03fbf1b747e
+  data.tar.gz: 9eee58a5c861c75a0e7b33e6aacf54648da80fd8969ebeadac75e1d418fb95dc
 SHA512:
-  metadata.gz: 1c62db83772abc00c2a6c1524c8a18f998b953ca227d8f521eaf2a3cb10e7457b078eac3d8d8473668e83c646e8f515a32700435fbc7a59edf715585f87e4eb7
-  data.tar.gz: 0cfa475365360aa17f5e7b81c215e07607eed6d10f867ba5269ef840c62aa88ca032944d613d11d7159b224593cbf0e2b67282aa1da5acdcad9621a7a99904fe
+  metadata.gz: f759a34fe7d102ae00aa9e1b048cdebc9c5731c3fad3bd502af77db8e16b311d4782465a5a47d4885c883435e930433b24b4972676cd72ecf85f5f37b954f1f8
+  data.tar.gz: cc905c3739263c36fdf92ccf62407c814721828e70ae50e36d1d7e79218abb58fbfd73209b21b56585c553915e86db53dfab54e17bcfa407c146ed4fa630b903

data/.travis.yml

@@ -1,12 +1,11 @@
 language: ruby
 before_install: gem update bundler
 rvm:
+  - ruby-head
+  - 2.5
   - 2.2
   - 2.1
   - 2.0
   - 1.9.3
-  - 1.9.2
-  - 1.8.7
   - jruby-18mode
   - jruby-19mode
-  - ree

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## 2.1.0rc1 (unreleased)
+
+Features:
+
+- Add `Delighted::AutopilotConfiguration.retrieve`
+- Add `Delighted::AutopilotMembership.list`
+- Add `Delighted::AutopilotMembership.create`
+- Add `Delighted::AutopilotMembership.delete`
+
+Compatibility changes:
+
+- Replace deprecated `URI::regexp` with `URI::DEFAULT_PARSER.make_regexp`
+
+## 2.0.0 (2020-03-18)
+
+Features:
+
+- Add `Delighted::Person.list`
+
+Compatibility changes:
+
+- Add support for Ruby 2.7
+- Drop support for Ruby 1.8.7, 1.9.2, and ree
+
+## 1.8.0 (2018-05-22)
+
+Features:
+
+- Add `Delighted::Person.delete`
+
 ## 1.7.0 (2017-10-18)
 
 Features:

data/README.md

@@ -49,6 +49,28 @@ updated_person1 = Delighted::Person.create(:email => "foo+test1@delighted.com",
   :name => "James Scott", :send => false)
 ```
 
+Listing all people:
+
+```ruby
+# List all people, auto pagination
+# Note: Make sure to handle the possible rate limits error
+people = Delighted::Person.list
+begin
+  people.auto_paging_each do |person|
+    # Do something with person
+  end
+rescue Delighted::RateLimitError => e
+  # Indicates how long to wait before making this request again
+  e.retry_after
+  retry
+end
+
+# For convenience, this method can use a sleep to automatically handle rate limits
+people.auto_paging_each({ auto_handle_rate_limits: true }) do |person|
+  # Do something with person
+end
+```
+
 Unsubscribing people:
 
 ```ruby
@@ -56,7 +78,7 @@ Unsubscribing people:
 Delighted::Unsubscribe.create(:person_email => "foo+test1@delighted.com")
 ```
 
-Listing people who have unsubscribed:
+Listing people who have unsubscribed (auto pagination not supported):
 
 ```ruby
 # List all people who have unsubscribed, 20 per page, first 2 pages
@@ -64,7 +86,7 @@ survey_responses_page1 = Delighted::Unsubscribe.all
 survey_responses_page2 = Delighted::Unsubscribe.all(:page => 2)
 ```
 
-Listing people whose emails have bounced:
+Listing people whose emails have bounced (auto pagination not supported):
 
 ```ruby
 # List all people whose emails have bounced, 20 per page, first 2 pages
@@ -72,6 +94,17 @@ survey_responses_page1 = Delighted::Bounce.all
 survey_responses_page2 = Delighted::Bounce.all(:page => 2)
 ```
 
+Deleting a person and all of the data associated with them:
+
+```ruby
+# Delete by person id
+Delighted::Person.delete(:id => 42)
+# Delete by email address
+Delighted::Person.delete(:email => "test@example.com")
+# Delete by phone number (must be E.164 format)
+Delighted::Person.delete(:phone_number => "+14155551212")
+```
+
 Deleting pending survey requests
 
 ```ruby
@@ -138,6 +171,80 @@ filtered_survey_responses = Delighted::SurveyResponse.all(:page => 5,
   :until => Time.utc(2013, 11, 01))
 ```
 
+Getting Autopilot state:
+
+```ruby
+email_autopilot_state = Delighted::AutopilotConfiguration.retrieve("email")
+sms_autopilot_state = Delighted::AutopilotConfiguration.retrieve("sms")
+```
+
+Listing Autopilot members:
+
+```ruby
+email_autopilot_members = Delighted::AutopilotMembership::Email.list
+begin
+  email_autopilot_members.auto_paging_each do |membership|
+    # Do something with membership
+  end
+rescue Delighted::RateLimitError => e
+  # Indicates how long to wait before making this request again
+  e.retry_after
+  retry
+end
+
+# For convenience, this method can use a sleep to automatically handle rate limits
+email_autopilot_members.auto_paging_each({ auto_handle_rate_limits: true }) do |membership|
+  # Do something with membership
+end
+```
+
+Look up specific Autopilot member:
+
+```ruby
+Delighted::AutopilotMembership::Email
+  .list(person_email: "foo+test1@delighted.com") # or person_id or person_phone_number
+  .auto_paging_each({ auto_handle_rate_limits: true }) do |membership|
+    # Do something with membership. If no membership for this person exists, 
+    # this block will never be called.
+end
+```
+
+Add a person to Autopilot:
+
+```ruby
+props = {
+  "Shoe Type" => "Sneaker",
+  "Handedness" => "Left"
+}
+result = Delighted::AutopilotMembership::Email.create(
+  person_email: "foo+test1@delighted.com", 
+  properties: props
+)
+```
+
+Update a person in Autopilot:
+
+```ruby
+props = {
+  "Shoe Type" => "Sandal",
+  "Handedness" => "Left"
+}
+result = Delighted::AutopilotMembership::Email.create(
+  person_email: "foo+test1@delighted.com", 
+  properties: props
+)
+```
+
+Remove a person from Autopilot:
+
+```ruby
+result = Delighted::AutopilotMembership::Sms.delete(
+  person_phone_number: "+15555551212"
+)
+
+result = Delighted::AutopilotMembership::Sms.delete(person_id: "433523")
+```
+
 Retrieving metrics:
 
 ```ruby

data/lib/delighted.rb

@@ -9,12 +9,15 @@ require 'delighted/version'
 require 'delighted/utils'
 require 'delighted/json'
 
+require 'delighted/list_resource'
 require 'delighted/enumerable_resource_collection'
 require 'delighted/resource'
 require 'delighted/operations/all'
+require 'delighted/operations/list'
 require 'delighted/operations/create'
 require 'delighted/operations/retrieve'
 require 'delighted/operations/update'
+require 'delighted/operations/delete'
 
 require 'delighted/resources/bounce'
 require 'delighted/resources/metrics'
@@ -23,6 +26,9 @@ require 'delighted/resources/survey_request'
 require 'delighted/resources/survey_response'
 require 'delighted/resources/unsubscribe'
 
+require 'delighted/resources/autopilot_configuration'
+require 'delighted/resources/autopilot_membership'
+
 require 'delighted/errors'
 require 'delighted/http_response'
 require 'delighted/http_adapter'

data/lib/delighted/client.rb

@@ -2,6 +2,7 @@ module Delighted
   class Client
     DEFAULT_API_BASE_URL = "https://api.delightedapp.com/v1"
     DEFAULT_HTTP_ADAPTER = HTTPAdapter.new
+    DEFAULT_ACCEPT_HEADER = "application/json"
 
     def initialize(opts = {})
       @api_key = opts[:api_key] or raise ArgumentError, "You must provide an API key by setting Delighted.api_key = '123abc' or passing { :api_key => '123abc' } when instantiating Delighted::Client.new"
@@ -10,13 +11,21 @@ module Delighted
     end
 
     def get_json(path, params = {})
-      headers = default_headers.dup.merge('Accept' => 'application/json')
+      request_get(path, {params: params})[:json]
+    end
 
-      uri = URI.parse(File.join(@api_base_url, path))
+    def request_get(path, opts = {})
+      accept_header = opts.fetch(:accept_header, DEFAULT_ACCEPT_HEADER)
+      params = opts.fetch(:params, {})
+
+      headers = default_headers.dup.merge('Accept' => accept_header)
+
+      path = File.join(@api_base_url, path) unless is_full_url(path)
+      uri = URI.parse(path)
       uri.query = Utils.to_query(params) unless params.empty?
 
       response = @http_adapter.request(:get, uri, headers)
-      handle_json_response(response)
+      { json: handle_json_response(response), response: response }
     end
 
     def post_json(path, params = {})
@@ -76,5 +85,9 @@ module Delighted
         'User-Agent' => "Delighted RubyGem #{Delighted::VERSION}"
       }.freeze
     end
+
+    def is_full_url(url)
+      !!(URI::DEFAULT_PARSER.make_regexp(%w(http https)) =~ url)
+    end
   end
 end

data/lib/delighted/errors.rb

@@ -38,4 +38,8 @@ module Delighted
   class ServiceUnavailableError < Error
     # 503, maintenance or overloaded
   end
+
+  class PaginationError < StandardError
+    # e.g. pagination completed
+  end
 end

data/lib/delighted/http_response.rb

@@ -12,6 +12,11 @@ module Delighted
       get_header_value("content-type")
     end
 
+    def next_link
+      link_header = get_header_value("link")
+      parse_link_header(link_header)[:next]
+    end
+
     def retry_after
       if value = get_header_value("retry-after")
         value.to_i
@@ -37,5 +42,22 @@ module Delighted
         end
       end
     end
+
+    def parse_link_header(header_value)
+      links = {}
+      parts = Array(header_value)
+                .map { |v| v.split(",") }
+                .flatten
+                .map(&:strip)
+      # Parse each part into a named link
+      parts.each do |part|
+        section = part.split(';')
+        next if section.length < 2
+        url = section[0][/<(.*)>/,1]
+        name = section[1][/rel="?([^"]*)"?/,1].to_sym
+        links[name] = url
+      end
+      links
+    end
   end
 end

data/lib/delighted/list_resource.rb

@@ -0,0 +1,45 @@
+module Delighted
+  class ListResource
+    def initialize(klass, path, opts, client)
+      @class = klass
+      @path = path
+      @opts = opts
+      @client = client
+      @iteration_count = 0
+      @done = false
+    end
+
+    def auto_paging_each(opts = {})
+      raise PaginationError, "pagination completed" if @done
+
+      auto_handle_rate_limits = opts.fetch(:auto_handle_rate_limits, false)
+      loop do
+        begin
+          # Get next (or first) page
+          if @iteration_count == 0
+            data = @client.request_get(@path, { params: @opts })
+          else
+            data = @client.request_get(@next_link)
+          end
+        rescue Delighted::RateLimitedError => e
+          if auto_handle_rate_limits
+            sleep e.retry_after
+            retry
+          else
+            raise
+          end
+        end
+
+        @iteration_count += 1
+        @next_link = data[:response].next_link
+
+        data[:json].map do |attributes|
+          yield @class.new(attributes)
+        end
+
+        break if @next_link.nil?
+      end
+      @done = true
+    end
+  end
+end

data/lib/delighted/operations/delete.rb

@@ -0,0 +1,20 @@
+module Delighted
+  module Operations
+    module Delete
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def path(id = nil)
+          id ? "#{@path}/#{CGI.escape(id)}" : @path
+        end
+
+        def delete(id_hash, client = Delighted.shared_client)
+          id = identifier_string(id_hash)
+          client.delete_json(path(id))
+        end
+      end
+    end
+  end
+end

data/lib/delighted/operations/list.rb

@@ -0,0 +1,15 @@
+module Delighted
+  module Operations
+    module List
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def list(opts = {}, client = Delighted.shared_client)
+          ListResource.new(self, path, Utils.serialize_values(opts), client)
+        end
+      end
+    end
+  end
+end

data/lib/delighted/resource.rb

@@ -11,6 +11,20 @@ module Delighted
       def singleton_resource?
         !!@singleton_resource
       end
+
+      def identifier_string(identifier_hash)
+        raise ArgumentError, "must pass Hash" unless Hash === identifier_hash
+        raise ArgumentError, "must pass exactly one identifier name and value" unless identifier_hash.size == 1
+
+        identifier_key = identifier_hash.keys.first
+        identifier_value = identifier_hash.values.first
+
+        if identifier_key.to_s == "id"
+          identifier_value.to_s
+        else
+          "#{identifier_key}:#{identifier_value}"
+        end
+      end
     end
 
     undef :id if method_defined?(:id)

data/lib/delighted/resources/autopilot_configuration.rb

@@ -0,0 +1,7 @@
+module Delighted
+  class AutopilotConfiguration < Resource
+    self.path = "/autopilot"
+
+    include Operations::Retrieve
+  end
+end

data/lib/delighted/resources/autopilot_membership.rb

@@ -0,0 +1,28 @@
+module Delighted
+  class AutopilotMembership < Resource
+    # This is a class purely so that Sms and Email share a common semantic base class
+
+    class << self
+      def delete(person_id_hash, client = Delighted.shared_client)
+        json = client.delete_json(path, person_id_hash)
+        json.merge(:person => Person.new(json[:person]))
+      end
+    end
+
+    class Sms < AutopilotMembership
+      self.path = "/autopilot/sms/memberships"
+      self.expandable_attributes = { :person => Person, :next_survey_request => SurveyRequest }
+
+      include Operations::List
+      include Operations::Create
+    end
+
+    class Email < AutopilotMembership
+      self.path = "/autopilot/email/memberships"
+      self.expandable_attributes = { :person => Person, :next_survey_request => SurveyRequest }
+
+      include Operations::List
+      include Operations::Create
+    end
+  end
+end

data/lib/delighted/resources/person.rb

@@ -3,5 +3,7 @@ module Delighted
     self.path = "/people"
 
     include Operations::Create
+    include Operations::Delete
+    include Operations::List
   end
 end

data/lib/delighted/version.rb

@@ -1,3 +1,3 @@
 module Delighted
-  VERSION = "1.7.0"
+  VERSION = "2.1.0rc1"
 end

data/test/delighted_test.rb

@@ -38,6 +38,129 @@ class Delighted::MetricsTest < Delighted::TestCase
 end
 
 class Delighted::PeopleTest < Delighted::TestCase
+  def test_listing_people_auto_paginate
+    uri = URI.parse("https://api.delightedapp.com/v1/people")
+    uri_next = URI.parse("https://api.delightedapp.com/v1/people.json?page_info=123456789")
+    headers = { "Authorization" => @auth_header, "Accept" => "application/json", "User-Agent" => "Delighted RubyGem #{Delighted::VERSION}" }
+
+    # First request mock
+    example_person1 = {:person_id => "4945", :email => "foo@example.com", :name => "Gold"}
+    example_person2 = {:person_id => "4946", :email => "foo+2@example.com", :name => "Silver"}
+    response = Delighted::HTTPResponse.new(200, {"Link" => "<#{uri_next}>; rel=\"next\""}, Delighted::JSON.dump([example_person1,example_person2]))
+    mock_http_adapter.expects(:request).with(:get, uri, headers).once.returns(response)
+
+    # Next request mock
+    example_person_next = {:person_id => "4947", :email => "foo+3@example.com", :name => "Bronze"}
+    response = Delighted::HTTPResponse.new(200, {}, Delighted::JSON.dump([example_person_next]))
+    mock_http_adapter.expects(:request).with(:get, uri_next, headers).once.returns(response)
+
+    persons_all = []
+    Delighted::Person.list.auto_paging_each do |p|
+      persons_all << p
+    end
+
+    assert_equal 3, persons_all.size
+
+    first_person = persons_all[0]
+    assert_kind_of Delighted::Person, first_person
+    assert_equal "Gold", first_person.name
+    assert_equal example_person1, first_person.to_hash
+    second_person = persons_all[1]
+    assert_kind_of Delighted::Person, second_person
+    assert_equal "Silver", second_person.name
+    assert_equal example_person2, second_person.to_hash
+    third_person = persons_all[2]
+    assert_kind_of Delighted::Person, third_person
+    assert_equal "Bronze", third_person.name
+    assert_equal example_person_next, third_person.to_hash
+  end
+
+  def test_listing_people_rate_limited
+    uri = URI.parse("https://api.delightedapp.com/v1/people")
+    uri_next = URI.parse("https://api.delightedapp.com/v1/people.json?page_info=123456789")
+    headers = { "Authorization" => @auth_header, "Accept" => "application/json", "User-Agent" => "Delighted RubyGem #{Delighted::VERSION}" }
+
+    # First request mock
+    example_person1 = {:person_id => "4945", :email => "foo@example.com", :name => "Gold"}
+    response = Delighted::HTTPResponse.new(200, {"Link" => "<#{uri_next}>; rel=\"next\""}, Delighted::JSON.dump([example_person1]))
+    mock_http_adapter.expects(:request).with(:get, uri, headers).once.returns(response)
+
+    # Next rate limited request mock
+    response = Delighted::HTTPResponse.new(429, { "Retry-After" => "10" }, {})
+    mock_http_adapter.expects(:request).with(:get, uri_next, headers).once.returns(response)
+
+    persons_all = []
+    exception = assert_raises Delighted::RateLimitedError do
+      Delighted::Person.list.auto_paging_each({ :auto_handle_rate_limits => false }) do |p|
+        persons_all << p
+      end
+    end
+
+    assert_equal 10, exception.retry_after
+
+    assert_equal 1, persons_all.size
+    first_person = persons_all[0]
+    assert_kind_of Delighted::Person, first_person
+    assert_equal "Gold", first_person.name
+    assert_equal example_person1, first_person.to_hash
+  end
+
+  def test_listing_people_auto_handle_rate_limits
+    uri = URI.parse("https://api.delightedapp.com/v1/people")
+    uri_next = URI.parse("https://api.delightedapp.com/v1/people.json?page_info=123456789")
+    headers = { "Authorization" => @auth_header, "Accept" => "application/json", "User-Agent" => "Delighted RubyGem #{Delighted::VERSION}" }
+
+    # First request mock
+    example_person1 = {:person_id => "4945", :email => "foo@example.com", :name => "Gold"}
+    response = Delighted::HTTPResponse.new(200, {"Link" => "<#{uri_next}>; rel=\"next\""}, Delighted::JSON.dump([example_person1]))
+    mock_http_adapter.expects(:request).with(:get, uri, headers).once.returns(response)
+
+    # Next rate limited request mock, then accepted request
+    response_rate_limited = Delighted::HTTPResponse.new(429, { "Retry-After" => "3" }, {})
+    example_person_next = {:person_id => "4947", :email => "foo+next@example.com", :name => "Silver"}
+    response_ok = Delighted::HTTPResponse.new(200, {}, Delighted::JSON.dump([example_person_next]))
+    mock_http_adapter.expects(:request).with(:get, uri_next, headers).twice.returns(response_rate_limited, response_ok)
+
+    persons_all = []
+    people = Delighted::Person.list
+    people.expects(:sleep).with(3)
+    people.auto_paging_each({ :auto_handle_rate_limits => true }) do |p|
+      persons_all << p
+    end
+
+    assert_equal 2, persons_all.size
+    first_person = persons_all[0]
+    assert_kind_of Delighted::Person, first_person
+    assert_equal "Gold", first_person.name
+    assert_equal example_person1, first_person.to_hash
+    next_person = persons_all[1]
+    assert_kind_of Delighted::Person, next_person
+    assert_equal "Silver", next_person.name
+    assert_equal example_person_next, next_person.to_hash
+  end
+
+  def test_listing_people_auto_paginate_second_call
+    uri = URI.parse("https://api.delightedapp.com/v1/people")
+    headers = { "Authorization" => @auth_header, "Accept" => "application/json", "User-Agent" => "Delighted RubyGem #{Delighted::VERSION}" }
+
+    # First request mock
+    example_person1 = {:person_id => "4945", :email => "foo@example.com", :name => "Gold"}
+    response = Delighted::HTTPResponse.new(200, {}, Delighted::JSON.dump([example_person1]))
+    mock_http_adapter.expects(:request).with(:get, uri, headers).once.returns(response)
+
+    persons_all = []
+    people = Delighted::Person.list
+    people.auto_paging_each do |p|
+      persons_all << p
+    end
+
+    assert_equal 1, persons_all.size
+
+    assert_raises Delighted::PaginationError do
+      people.auto_paging_each
+    end
+  end
+
   def test_creating_or_updating_a_person
     uri = URI.parse("https://api.delightedapp.com/v1/people")
     headers = { 'Authorization' => @auth_header, "Accept" => "application/json", 'Content-Type' => 'application/json', 'User-Agent' => "Delighted RubyGem #{Delighted::VERSION}" }
@@ -80,6 +203,43 @@ class Delighted::PeopleTest < Delighted::TestCase
     assert_kind_of Hash, result
     assert_equal({ :ok => true }, result)
   end
+
+  def test_deleting_a_person_with_multiple_identifiers
+    assert_raises(ArgumentError) { Delighted::Person.delete(:id => 57, :email => "foo@example.com") }
+  end
+
+  def test_deleting_a_person_by_id
+    uri = URI.parse("https://api.delightedapp.com/v1/people/57")
+    headers = { 'Authorization' => @auth_header, "Accept" => "application/json", 'Content-Type' => 'application/json', 'User-Agent' => "Delighted RubyGem #{Delighted::VERSION}" }
+    response = Delighted::HTTPResponse.new(202, {}, Delighted::JSON.dump({ :ok => true }))
+    mock_http_adapter.expects(:request).with(:delete, uri, headers, nil).once.returns(response)
+
+    result = Delighted::Person.delete(:id => 57)
+    assert_kind_of Hash, result
+    assert_equal({ :ok => true }, result)
+  end
+
+  def test_deleting_a_person_by_email
+    uri = URI.parse("https://api.delightedapp.com/v1/people/email%3Afoo%40bar.com")
+    headers = { 'Authorization' => @auth_header, "Accept" => "application/json", 'Content-Type' => 'application/json', 'User-Agent' => "Delighted RubyGem #{Delighted::VERSION}" }
+    response = Delighted::HTTPResponse.new(202, {}, Delighted::JSON.dump({ :ok => true }))
+    mock_http_adapter.expects(:request).with(:delete, uri, headers, nil).once.returns(response)
+
+    result = Delighted::Person.delete(:email => "foo@bar.com")
+    assert_kind_of Hash, result
+    assert_equal({ :ok => true }, result)
+  end
+
+  def test_deleting_a_person_by_phone_number
+    uri = URI.parse("https://api.delightedapp.com/v1/people/phone_number%3A%2B14155551212")
+    headers = { 'Authorization' => @auth_header, "Accept" => "application/json", 'Content-Type' => 'application/json', 'User-Agent' => "Delighted RubyGem #{Delighted::VERSION}" }
+    response = Delighted::HTTPResponse.new(202, {}, Delighted::JSON.dump({ :ok => true }))
+    mock_http_adapter.expects(:request).with(:delete, uri, headers, nil).once.returns(response)
+
+    result = Delighted::Person.delete(:phone_number => "+14155551212")
+    assert_kind_of Hash, result
+    assert_equal({ :ok => true }, result)
+  end
 end
 
 class Delighted::SurveyResponseTest < Delighted::TestCase
@@ -227,3 +387,211 @@ class Delighted::BouncesTest < Delighted::TestCase
   end
 end
 
+class Delighted::AutopilotConfigurationsTest < Delighted::TestCase
+  def test_getting_sms_autopilot_configuration
+    uri = URI.parse("https://api.delightedapp.com/v1/autopilot/sms")
+    headers = { 'Authorization' => @auth_header, "Accept" => "application/json", 'User-Agent' => "Delighted RubyGem #{Delighted::VERSION}" }
+    response = Delighted::HTTPResponse.new(200, {}, Delighted::JSON.dump({ :platform_id => 'sms', :active => true, :frequency => 7776000, :created_at => 1611253998, :updated_at => 1618421598 }))
+    mock_http_adapter.expects(:request).with(:get, uri, headers).once.returns(response)
+
+    configuration = Delighted::AutopilotConfiguration.retrieve('sms')
+    assert_kind_of Delighted::AutopilotConfiguration, configuration
+    assert_equal({ :platform_id => 'sms', :active => true, :frequency => 7776000, :created_at => 1611253998, :updated_at => 1618421598 }, configuration.to_hash)
+    assert_equal 'sms', configuration.platform_id
+    assert_equal true, configuration.active
+    assert_equal 7776000, configuration.frequency
+    assert_equal 1611253998, configuration.created_at
+    assert_equal 1618421598, configuration.updated_at
+  end
+end
+
+class Delighted::AutopilotMembershipsTest < Delighted::TestCase
+  def test_listing_autopilot_memberships
+    first_membership = {
+      :created_at => 1611253998,
+      :updated_at => 1618421598,
+      :person => {
+        :id => "34",
+        :name => "Leslie",
+        :email => "leslie@example.com",
+        :created_at => 1611365037,
+        :phone_number => "+1555555112",
+        :last_sent_at => nil
+      },
+      :next_survey_request => {
+        :id => "42",
+        :created_at => 1614043237,
+        :survey_scheduled_at => 1620087437,
+        :properties => { :"Purchase Experience" => "Web", :"State" => "OR" }
+      }
+    }
+    second_membership = {
+      :created_at => 1611243998,
+      :updated_at => 1618420598,
+      :person => {
+        :id => "42",
+        :name => "Taylor",
+        :email => "taylor@example.com",
+        :created_at => 1611242998,
+        :phone_number => "+1555551212",
+        :last_sent_at => 1611242998
+      },
+      :next_survey_request => {
+        :id => "3445",
+        :created_at => 1614043437,
+        :survey_scheduled_at => 1620087837,
+        :properties => { :"Purchase Experience" => "Mobile", :"State" => "CA" }
+      }
+    }
+    third_membership = {
+      :created_at => 1611143998,
+      :updated_at => 1618320598,
+      :person => {
+        :id => "47",
+        :name => "Casey",
+        :email => "casey@example.com",
+        :created_at => 1610242998,
+        :phone_number => "+1555551234",
+        :last_sent_at => 1610242998
+      },
+      :next_survey_request => {
+        :id => "3449",
+        :created_at => 1614063437,
+        :survey_scheduled_at => 1620097837,
+        :properties => { :"Purchase Experience" => "Store", :"State" => "WA" }
+      }
+    }
+    uri = URI.parse("https://api.delightedapp.com/v1/autopilot/sms/memberships")
+    uri_next = URI.parse("https://api.delightedapp.com/v1/autopilot/sms/memberships?page_info=123456789")
+    headers = { "Authorization" => @auth_header, "Accept" => "application/json", "User-Agent" => "Delighted RubyGem #{Delighted::VERSION}" }
+
+    # First request mock
+    response = Delighted::HTTPResponse.new(200, {"Link" => "<#{uri_next}>; rel=\"next\""}, Delighted::JSON.dump([first_membership, second_membership]))
+    mock_http_adapter.expects(:request).with(:get, uri, headers).once.returns(response)
+
+    # Next request mock
+    response = Delighted::HTTPResponse.new(200, {}, Delighted::JSON.dump([third_membership]))
+    mock_http_adapter.expects(:request).with(:get, uri_next, headers).once.returns(response)
+
+    memberships = []
+    Delighted::AutopilotMembership::Sms.list.auto_paging_each do |membership|
+      memberships << membership
+    end
+
+    assert_equal 3, memberships.size
+    assert_kind_of Delighted::AutopilotMembership::Sms, memberships[0]
+    assert_kind_of Delighted::Person, memberships[0].person
+    assert_kind_of Delighted::SurveyRequest, memberships[0].next_survey_request
+    assert_equal 1611253998, memberships[0].created_at
+    assert_equal "34", memberships[0].person.id
+    assert_nil memberships[0].person.last_sent_at
+    assert_equal first_membership[:person].reject { |k,_| k == :id }, memberships[0].person.to_hash
+    assert_equal "+1555555112", memberships[0].person.phone_number
+    assert_equal 1620087437, memberships[0].next_survey_request.survey_scheduled_at
+    assert_equal first_membership[:next_survey_request][:properties], memberships[0].next_survey_request.properties
+    assert_kind_of Delighted::AutopilotMembership, memberships[1]
+    assert_equal 1611242998, memberships[1].person.last_sent_at
+  end
+
+  def test_listing_specific_autopilot_memberships
+    specific_membership = {
+      :created_at => 1611253998,
+      :updated_at => 1618421598,
+      :person => {
+        :id => "34",
+        :name => "Leslie",
+        :email => "leslie@example.com",
+        :created_at => 1611365037,
+        :phone_number => "+1555555112",
+        :last_sent_at => nil
+      },
+      :next_survey_request => {
+        :id => "42",
+        :created_at => 1614043237,
+        :survey_scheduled_at => 1620087437,
+        :properties => {
+          :"Purchase Experience" => "Web",
+          :"State" => "OR"
+        }
+      }
+    }
+    uri = URI.parse("https://api.delightedapp.com/v1/autopilot/sms/memberships?person_id=34")
+    headers = { "Authorization" => @auth_header, "Accept" => "application/json", "User-Agent" => "Delighted RubyGem #{Delighted::VERSION}" }
+    response = Delighted::HTTPResponse.new(200, {}, Delighted::JSON.dump([specific_membership]))
+    mock_http_adapter.expects(:request).with(:get, uri, headers).once.returns(response)
+
+    memberships = []
+    Delighted::AutopilotMembership::Sms.list(person_id: 34).auto_paging_each do |membership|
+      memberships << membership
+    end
+
+    assert_equal 1, memberships.size
+    assert_kind_of Delighted::AutopilotMembership::Sms, memberships[0]
+    assert_kind_of Delighted::Person, memberships[0].person
+    assert_kind_of Delighted::SurveyRequest, memberships[0].next_survey_request
+    assert_equal 1, memberships.size
+  end
+
+  def test_adding_autopilot_membership
+    params = {
+      person_email: "leslie@example.com",
+      person_name: "Leslie",
+      properties: {
+        :"Purchase Experience" => "Web",
+        :"State" => "OR"
+      }
+    }
+    uri = URI.parse("https://api.delightedapp.com/v1/autopilot/email/memberships")
+    headers = { "Authorization" => @auth_header, "Accept" => "application/json", 'Content-Type' => 'application/json', "User-Agent" => "Delighted RubyGem #{Delighted::VERSION}" }
+    response = Delighted::HTTPResponse.new(200, {}, Delighted::JSON.dump({ person: { id: "333", name: params[:person_name], email: params[:person_email] }, properties: params[:properties] }))
+    mock_http_adapter.expects(:request).with(:post, uri, headers, Delighted::JSON.dump(params)).once.returns(response)
+
+    result = Delighted::AutopilotMembership::Email.create(params)
+
+    assert_kind_of Delighted::AutopilotMembership::Email, result
+    assert_kind_of Delighted::Person, result.person
+    assert_equal params[:properties], result.properties
+    assert_equal params[:person_email], result.person.email
+    assert_equal params[:person_name], result.person.name
+    assert result.person.id
+    assert_equal params[:properties], result.properties
+  end
+
+  def test_updating_autopilot_membership
+    params = {
+      person_id: "333",
+      properties: {
+        :"Purchase Experience" => "Web",
+        :"State" => "OR"
+      }
+    }
+    uri = URI.parse("https://api.delightedapp.com/v1/autopilot/sms/memberships")
+    headers = { "Authorization" => @auth_header, "Accept" => "application/json", 'Content-Type' => 'application/json', "User-Agent" => "Delighted RubyGem #{Delighted::VERSION}" }
+    response = Delighted::HTTPResponse.new(200, {}, Delighted::JSON.dump({ person: { id: "333", name: "Leslie", email: "leslie@example.com", phone_numer: "+15555551212" }, properties: params[:properties] }))
+    mock_http_adapter.expects(:request).with(:post, uri, headers, Delighted::JSON.dump(params)).once.returns(response)
+
+    result = Delighted::AutopilotMembership::Sms.create(params)
+
+    assert_kind_of Delighted::AutopilotMembership::Sms, result
+    assert_kind_of Delighted::Person, result.person
+    assert_equal params[:properties], result.properties
+    assert_equal "leslie@example.com", result.person.email
+    assert_equal "Leslie", result.person.name
+    assert_equal "333", result.person.id
+    assert_equal params[:properties], result.properties
+  end
+
+  def test_removing_autopilot_membership
+    uri = URI.parse("https://api.delightedapp.com/v1/autopilot/sms/memberships")
+    headers = { "Authorization" => @auth_header, "Accept" => "application/json", 'Content-Type' => 'application/json', "User-Agent" => "Delighted RubyGem #{Delighted::VERSION}" }
+    response = Delighted::HTTPResponse.new(200, {}, Delighted::JSON.dump({ person: { id: "333", name: "Leslie", email: "leslie@example.com"} }))
+    mock_http_adapter.expects(:request).with(:delete, uri, headers, Delighted::JSON.dump({person_id: "455"})).once.returns(response)
+
+    result = Delighted::AutopilotMembership::Sms.delete(:person_id => "455")
+
+    assert_kind_of Hash, result
+    assert_equal "leslie@example.com", result[:person].email
+    assert_equal "Leslie", result[:person].name
+    assert_equal "333", result[:person].id
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delighted
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 2.1.0rc1
 platform: ruby
 authors:
 - Mark Dodwell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-18 00:00:00.000000000 Z
+date: 2021-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -88,11 +88,16 @@ files:
 - lib/delighted/http_adapter.rb
 - lib/delighted/http_response.rb
 - lib/delighted/json.rb
+- lib/delighted/list_resource.rb
 - lib/delighted/operations/all.rb
 - lib/delighted/operations/create.rb
+- lib/delighted/operations/delete.rb
+- lib/delighted/operations/list.rb
 - lib/delighted/operations/retrieve.rb
 - lib/delighted/operations/update.rb
 - lib/delighted/resource.rb
+- lib/delighted/resources/autopilot_configuration.rb
+- lib/delighted/resources/autopilot_membership.rb
 - lib/delighted/resources/bounce.rb
 - lib/delighted/resources/metrics.rb
 - lib/delighted/resources/person.rb
@@ -119,12 +124,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Delighted is the fastest and easiest way to gather actionable feedback from