twitter-ads 5.2.0 → 6.0.0

data/lib/twitter-ads/resources/dsl.rb

@@ -20,7 +20,14 @@ module TwitterAds
       # @return [self] A fully hydrated instance of the current class.
       #
       # @since 0.1.0
-      def from_response(object)
+      def from_response(object, headers = nil)
+        if !headers.nil?
+          TwitterAds::Utils.extract_response_headers(headers).each { |key, value|
+            singleton_class.class_eval { attr_accessor key }
+            instance_variable_set("@#{key}", value)
+          }
+        end
+
         self.class.properties.each do |name, type|
           value = nil
           if type == :time && object[name] && !object[name].empty?

data/lib/twitter-ads/restapi.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# Copyright (C) 2019 Twitter, Inc.
+
+module TwitterRestApi
+  class UserIdLookup
+    include TwitterAds::DSL
+    include TwitterAds::Resource
+
+    attr_reader :account
+
+    property :id, read_only: true
+    property :id_str, read_only: true
+    property :screen_name, read_only: true
+
+    DOMAIN = 'https://api.twitter.com'
+    RESOURCE = '/1.1/users/show.json'
+
+    def self.load(account, opts = {})
+      response = TwitterAds::Request.new(
+        account.client,
+        :get,
+        RESOURCE,
+        params: opts,
+        domain: DOMAIN
+      ).perform
+      new.from_response(response.body, response.headers)
+    end
+  end
+end

data/lib/twitter-ads/settings/tax.rb

@@ -41,12 +41,24 @@ module TwitterAds
     property :to_delete, type: :bool
 
     RESOURCE = "/#{TwitterAds::API_VERSION}/" \
-               'accounts/%{account_id}/user_settings/%{id}' # @api private
+               'accounts/%{account_id}/tax_settings' # @api private
 
     def initialize(account)
       @account = account
       self
     end
 
+    def self.load(account)
+      resource = RESOURCE % { account_id: account.id }
+      response = Request.new(account.client, :get, resource).perform
+      new(account).from_response(response.body[:data])
+    end
+
+    def save
+      resource = RESOURCE % { account_id: account.id }
+      params = to_params
+      response = Request.new(account.client, :put, resource, params: params).perform
+      from_response(response.body[:data])
+    end
   end
 end

data/lib/twitter-ads/targeting_criteria/conversation.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# Copyright (C) 2019 Twitter, Inc.
+
+module TwitterAds
+  class Conversation
+
+    include TwitterAds::DSL
+    include TwitterAds::Resource
+
+    property :name, read_only: true
+    property :targeting_type, read_only: true
+    property :targeting_value, read_only: true
+    property :conversation_type, read_only: true
+
+    RESOURCE_COLLECTION = "/#{TwitterAds::API_VERSION}/" \
+                          'targeting_criteria/conversations' # @api private
+
+    def initialize(account)
+      @account = account
+      self
+    end
+  end
+end

data/lib/twitter-ads/utils.rb

@@ -70,6 +70,29 @@ module TwitterAds
         warn message
       end
 
+      def extract_response_headers(headers)
+        values = {}
+        # only get "X-${name}" custom response headers
+        headers.each { |key, value|
+          if key =~ /^x-/
+            values[key.gsub(/^x-/, '').tr('-', '_')] = \
+              value.first =~ /^[0-9]*$/ ? value.first.to_i : value.first
+          end
+        }
+        values
+      end
+
+      def flatten_params(args)
+        params = args
+        params.each { |key, value|
+          if value.is_a?(Array)
+            next if value.empty?
+            params[key] = value.join(',')
+          end
+        }
+        params
+      end
+
     end
 
   end

data/lib/twitter-ads/version.rb

@@ -2,5 +2,5 @@
 # Copyright (C) 2019 Twitter, Inc.
 
 module TwitterAds
-  VERSION = '5.2.0'
+  VERSION = '6.0.0'
 end

data/spec/fixtures/tweet_previews.json

@@ -0,0 +1,23 @@
+{
+  "data_type": "tweet_previews",
+  "request": {
+    "params": {
+      "tweet_ids": [
+        "1130942781109596160",
+        "1101254234031370240"
+      ],
+      "tweet_type": "PUBLISHED",
+      "account_id": "2iqph"
+    }
+  },
+  "data": [
+    {
+      "tweet_id": "1130942781109596160",
+      "preview": "<iframe class='tweet-preview' src='https://ton.smf1.twitter.com/ads-manager/tweet-preview/index.html?data=c29tZSByYW5kb20gYmFzZTY0IHN0cmluZ3MgaGVyZS4uLg=='>"
+    },
+    {
+      "tweet_id": "1101254234031370240",
+      "preview": "<iframe class='tweet-preview' src='https://ton.smf1.twitter.com/ads-manager/tweet-preview/index.html?data=c29tZSByYW5kb20gYmFzZTY0IHN0cmluZ3MgaGVyZS4uLg=='>"
+    }
+  ]
+}

data/spec/twitter-ads/campaign/targeting_criteria_spec.rb

@@ -31,7 +31,6 @@ describe TwitterAds::TargetingCriteria do
     targeting_type
     targeting_value
     tailored_audience_expansion
-    tailored_audience_type
   )
 
   include_examples 'object property check', read, write

data/spec/twitter-ads/campaign/tweet_spec.rb

@@ -21,63 +21,4 @@ describe TwitterAds::Tweet do
 
   let(:account) { client.accounts.first }
 
-  describe '#tweet_preview' do
-
-    let!(:resource_collection) { "#{ADS_API}/accounts/#{account.id}/tweet/preview" }
-
-    before(:each) do
-      stub_fixture(:get, :tweet_preview, /#{resource_collection}.*/)
-    end
-
-    context 'with an existing tweet id' do
-
-      it 'successfully returns a preview of the specified tweet' do
-        params = { id: 634798319504617472 }
-        result = subject.preview(account, params)
-        expect(result.size).not_to be_nil
-        expect(result).to all(include(:platform, :preview))
-      end
-
-    end
-
-    context 'when previewing a new tweet' do
-
-      it 'url encodes the status content' do
-        params = { text: 'Hello World!', card_id: '19v69' }
-        expect(URI).to receive(:escape).at_least(:once).and_call_original
-        result = subject.preview(account, params)
-        expect(result.size).not_to be_nil
-        expect(result).to all(include(:platform, :preview))
-      end
-
-      it 'allows a single value for the media_ids param' do
-        resource = "/#{TwitterAds::API_VERSION}/accounts/#{account.id}/tweet/preview"
-        expected = { text: 'Hello%20World!', media_ids: 634458428836962304 }
-
-        expect(TwitterAds::Request).to receive(:new).with(
-          account.client, :get, resource, params: expected).and_call_original
-
-        params = { text: 'Hello World!', media_ids: 634458428836962304 }
-        result = subject.preview(account, params)
-        expect(result.size).not_to be_nil
-        expect(result).to all(include(:platform, :preview))
-      end
-
-      it 'allows an array of values for the media_ids param' do
-        resource = "/#{TwitterAds::API_VERSION}/accounts/#{account.id}/tweet/preview"
-        expected = { text: 'Hello%20World!', media_ids: '634458428836962304,634458428836962305' }
-
-        expect(TwitterAds::Request).to receive(:new).with(
-          account.client, :get, resource, params: expected).and_call_original
-
-        params = { text: 'Hello World!', media_ids: [634458428836962304, 634458428836962305] }
-        result = subject.preview(account, params)
-        expect(result.size).not_to be_nil
-        expect(result).to all(include(:platform, :preview))
-      end
-
-    end
-
-  end
-
 end

data/spec/twitter-ads/client_spec.rb

@@ -55,10 +55,26 @@ describe TwitterAds::Client do
 
     it 'allows additional options' do
       expect {
-        Client.new(consumer_key, consumer_secret, access_token, {})
+        Client.new(consumer_key, consumer_secret, access_token, access_token_secret, options: {})
       }.not_to raise_error
     end
 
+    it 'test client options' do
+      client = Client.new(
+        consumer_key,
+        consumer_secret,
+        access_token,
+        access_token_secret,
+        options: {
+          handle_rate_limit: true,
+          retry_max: 1,
+          retry_delay: 3000,
+          retry_on_status: [404, 500, 503]
+        }
+      )
+      expect(client.options.length).to eq 4
+    end
+
   end
 
   describe '#inspect' do

data/spec/twitter-ads/creative/tweet_previews_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+# Copyright (C) 2019 Twitter, Inc.
+
+require 'spec_helper'
+
+include TwitterAds::Enum
+
+describe TwitterAds::Creative::TweetPreview do
+
+  let!(:resource) { "#{ADS_API}/accounts/2iqph/tweet_previews" }
+
+  before(:each) do
+    stub_fixture(:get, :accounts_load, "#{ADS_API}/accounts/2iqph")
+    stub_fixture(:get, :tweet_previews, /#{resource}\?.*/)
+  end
+
+  let(:client) do
+    Client.new(
+      Faker::Lorem.characters(40),
+      Faker::Lorem.characters(40),
+      Faker::Lorem.characters(40),
+      Faker::Lorem.characters(40)
+    )
+  end
+
+  let(:account) { client.accounts('2iqph') }
+  let(:instance) { described_class.new(account) }
+
+  it 'inspect TweetPreview.load() response' do
+    preview = instance.load(
+      account,
+      tweet_ids: %w(1130942781109596160 1101254234031370240),
+      tweet_type: TweetType::PUBLISHED)
+
+    expect(preview).to be_instance_of(Cursor)
+    expect(preview.count).to eq 2
+    tweet = preview.first
+    expect(tweet.tweet_id).to eq '1130942781109596160'
+  end
+
+end

data/spec/twitter-ads/rate_limit_spec.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+# Copyright (C) 2019 Twitter, Inc.
+
+require 'spec_helper'
+
+describe TwitterAds::Campaign do
+
+  before(:each) do
+    allow_any_instance_of(Object).to receive(:sleep)
+    stub_fixture(:get, :accounts_load, "#{ADS_API}/accounts/2iqph")
+  end
+
+  let(:client) do
+    Client.new(
+      Faker::Lorem.characters(40),
+      Faker::Lorem.characters(40),
+      Faker::Lorem.characters(40),
+      Faker::Lorem.characters(40)
+    )
+  end
+  let(:account) { client_simple.accounts('2iqph') }
+
+  let(:client_simple) do
+    Client.new(
+      Faker::Lorem.characters(40),
+      Faker::Lorem.characters(40),
+      Faker::Lorem.characters(40),
+      Faker::Lorem.characters(40),
+      options: {
+        handle_rate_limit: true
+      }
+    )
+  end
+  let(:account1) { client_simple.accounts('2iqph') }
+
+  let(:client_combine) do
+    Client.new(
+      Faker::Lorem.characters(40),
+      Faker::Lorem.characters(40),
+      Faker::Lorem.characters(40),
+      Faker::Lorem.characters(40),
+      options: {
+        handle_rate_limit: true,
+        retry_max: 1,
+        retry_delay: 3000,
+        retry_on_status: [500]
+      }
+    )
+  end
+  let(:account2) { client_combine.accounts('2iqph') }
+
+  it 'test rate-limit handle - success' do
+    stub = stub_request(:get, "#{ADS_API}/accounts/2iqph/campaigns").to_return(
+      {
+        body: fixture(:campaigns_all),
+        status: 429,
+        headers: {
+          'x-account-rate-limit-limit': 10000,
+          'x-account-rate-limit-remaining': 9999,
+          'x-account-rate-limit-reset': Time.now.to_i + 5
+        }
+      },
+      {
+        body: fixture(:campaigns_all),
+        status: 200
+      }
+    )
+    cusor = described_class.all(account1)
+    expect(cusor).to be_instance_of(Cursor)
+    expect(stub).to have_been_requested.times(2)
+  end
+
+  it 'test rate-limit handle - fail' do
+    stub = stub_request(:get, "#{ADS_API}/accounts/2iqph/campaigns").to_return(
+      {
+        body: fixture(:campaigns_all),
+        status: 429,
+        headers: {
+          'x-account-rate-limit-limit': 10000,
+          'x-account-rate-limit-remaining': 9999,
+          'x-account-rate-limit-reset': Time.now.to_i + 5
+        }
+      },
+      {
+        body: fixture(:campaigns_all),
+        status: 429,
+        headers: {
+          'x-account-rate-limit-limit': 10000,
+          'x-account-rate-limit-remaining': 9999,
+          'x-account-rate-limit-reset': 4102444800
+        }
+      }
+    )
+    begin
+      cusor = described_class.all(account1)
+    rescue RateLimit => e
+      cusor = e
+    end
+    expect(cusor).to be_instance_of(RateLimit)
+    expect(stub).to have_been_requested.times(2)
+    expect(cusor.reset_at).to eq 4102444800
+  end
+
+  it 'test rate-limit handle with retry - case 1' do
+    # scenario:
+    #  - 500 (retry) -> 429 (handle rate limit) -> 200 (end)
+    stub = stub_request(:get, "#{ADS_API}/accounts/2iqph/campaigns").to_return(
+      {
+        body: fixture(:campaigns_all),
+        status: 500,
+        headers: {
+          'x-account-rate-limit-limit': 10000,
+          'x-account-rate-limit-remaining': 9999,
+          'x-account-rate-limit-reset': 4102444800
+        }
+      },
+      {
+        body: fixture(:campaigns_all),
+        status: 429,
+        headers: {
+          'x-account-rate-limit-limit': 10000,
+          'x-account-rate-limit-remaining': 9999,
+          'x-account-rate-limit-reset': Time.now.to_i + 5
+        }
+      },
+      {
+        body: fixture(:campaigns_all),
+        status: 200
+      }
+    )
+    cusor = described_class.all(account2)
+    expect(cusor).to be_instance_of(Cursor)
+    expect(stub).to have_been_requested.times(3)
+  end
+
+  it 'test rate-limit handle with retry - case 2' do
+    # scenario:
+    #  - 429 (handle rate limit) -> 500 (retry) -> 200 (end)
+    stub = stub_request(:get, "#{ADS_API}/accounts/2iqph/campaigns").to_return(
+      {
+        body: fixture(:campaigns_all),
+        status: 429,
+        headers: {
+          'x-account-rate-limit-limit': 10000,
+          'x-account-rate-limit-remaining': 9999,
+          'x-account-rate-limit-reset': Time.now.to_i + 5
+        }
+      },
+      {
+        body: fixture(:campaigns_all),
+        status: 500,
+        headers: {
+          'x-account-rate-limit-limit': 10000,
+          'x-account-rate-limit-remaining': 9999,
+          'x-account-rate-limit-reset': 4102444800
+        }
+      },
+      {
+        body: fixture(:campaigns_all),
+        status: 200
+      }
+    )
+    cusor = described_class.all(account2)
+    expect(cusor).to be_instance_of(Cursor)
+    expect(stub).to have_been_requested.times(3)
+  end
+
+  it 'test rate-limit header access from cusor class' do
+    stub_request(:get, "#{ADS_API}/accounts/2iqph/campaigns").to_return(
+      {
+        body: fixture(:campaigns_all),
+        status: 200,
+        headers: {
+          'x-account-rate-limit-limit': 10000,
+          'x-account-rate-limit-remaining': 9999,
+          'x-account-rate-limit-reset': 4102444800
+        }
+      }
+    )
+    cusor = described_class.all(account)
+    expect(cusor).to be_instance_of(Cursor)
+    expect(cusor.account_rate_limit_limit).to eq 10000
+    expect(cusor.account_rate_limit_remaining).to eq 9999
+    expect(cusor.account_rate_limit_reset).to eq 4102444800
+  end
+
+  it 'test rate-limit header access from resource class' do
+    stub_request(:any, /accounts\/2iqph\/campaigns\/2wap7/).to_return(
+      {
+        body: fixture(:campaigns_load),
+        status: 200,
+        headers: {
+          'x-account-rate-limit-limit': 10000,
+          'x-account-rate-limit-remaining': 9999,
+          'x-account-rate-limit-reset': 4102444800
+        }
+      }
+    )
+
+    campaign = described_class.load(account, '2wap7')
+    resource = "/#{TwitterAds::API_VERSION}/accounts/2iqph/campaigns/2wap7"
+    params   = {}
+    response = TwitterAds::Request.new(client, :get, resource, params: params).perform
+    data     = campaign.from_response(response.body[:data], response.headers)
+    expect(data).to be_instance_of(Campaign)
+    expect(data.account_rate_limit_limit).to eq 10000
+    expect(data.account_rate_limit_remaining).to eq 9999
+    expect(data.account_rate_limit_reset).to eq 4102444800
+  end
+
+  it 'test rate-limit header access check instance variables not conflicting' do
+    stub_request(:get, "#{ADS_API}/accounts/2iqph/campaigns").to_return(
+      {
+        body: fixture(:campaigns_all),
+        status: 200,
+        headers: {
+          'x-account-rate-limit-limit': 10000,
+          'x-account-rate-limit-remaining': 9999,
+          'x-account-rate-limit-reset': 4102444800
+        }
+      },
+      {
+        body: fixture(:campaigns_all),
+        status: 200,
+        headers: {
+          'x-account-rate-limit-limit': 10000,
+          'x-account-rate-limit-remaining': 9998,
+          'x-account-rate-limit-reset': 4102444800
+        }
+      }
+    )
+
+    campaign_first = described_class.all(account)
+    campaign_second = described_class.all(account)
+
+    expect(campaign_first).to be_instance_of(Cursor)
+    expect(campaign_first.account_rate_limit_limit).to eq 10000
+    expect(campaign_first.account_rate_limit_remaining).to eq 9999
+    expect(campaign_first.account_rate_limit_reset).to eq 4102444800
+
+    expect(campaign_second).to be_instance_of(Cursor)
+    expect(campaign_second.account_rate_limit_limit).to eq 10000
+    expect(campaign_second.account_rate_limit_remaining).to eq 9998
+    expect(campaign_second.account_rate_limit_reset).to eq 4102444800
+  end
+
+end