zanox_publisher 0.1.0

data/lib/zanox_publisher/program.rb

@@ -0,0 +1,241 @@
+module ZanoxPublisher
+  # Programs
+  #
+  # Get advertiser programs
+  #
+  # @attr [Integer]         id                    The programItem's identifer from Zanox
+  # @attr [String]          name                  The name of the advertiser
+  # @attr [Fixnum]          adrank                The adrank of the advertiser
+  # @attr [Boolean]         application_required  States whether a direct application is required
+  # @attr [String]          description           The description from the advertiser
+  # @attr [String]          description_local     The description from the advertiser in connect ID language
+  # @attr [Integer]         products              The number of products from the advertiser
+  # @attr [Vertical]        vertical              The vertical of the advertiser
+  # @attr [Array<String>]   regions               The regions the advertiser is active in
+  # @attr [Array<Category>] categories            The categories of the advertiser
+  # @attr [DateTime]        start_date            The start date of the program
+  # @attr [String]          url                   The url for the program
+  # @attr [String]          image                 The image for the program
+  # @attr [String]          currency              The currency of the program
+  # @attr [String]          status                The status of the program, with active stating the program is still a live
+  # @attr [String]          terms                 The terms of the program
+  # @attr [String]          terms_url             The terms url
+  # @attr [Array<Policy>]   policies              The policies to follow for the program
+  # @attr [String]          return_time_leads     The return time in which a lead is given
+  # @attr [String]          return_time_sales     The return time in which a sale is given
+  class Program < Base
+    RESOURCE_PATH = '/programs'
+
+    PROGRAM_STATUS_ENUM = %w(active inactive)
+
+    class << self
+      # Retrieves all programs dependent on search parameters.
+      #
+      # This is equivalent to the Zanox API method SearchPrograms.
+      # The method documentation can be found under {https://developer.zanox.com/web/guest/publisher-api-2011/get-programs}.
+      #
+      # Authentication: Requires connect ID.
+      #
+      # This can require multiple requests, as internally every page is pulled.
+      # The ZanoxPublisher::Program.page function can be used to better control the requests made.
+      #
+      # @param query [String] Limits results to programs associated with this search string (API equivalent is q).
+      # @param q [String] Limits results to programs associated with this search string (API name).
+      # @param start_date [Date] Limits results to programs activated after this date (API equivalent is startdate).
+      # @param startdate [Date] Limits results to programs activated after this date (API name).
+      # @param region [String] Limits results to a particular region.
+      # @param partnership [String] Limits results to programs with mandatory direct applications ("DIRECT") or not requiring direct application ("INDIRECT").
+      # @param has_products [Boolean] Limits results to programs with products (API equivalent is hasproducts).
+      # @param hasproducts [Boolean] Limits results to programs with products (API name).
+      #
+      # @return [Array<Program>]
+      def all(options = {})
+        retval = []
+        current_page = 0
+        options.merge!({ per_page: maximum_per_page })
+
+        begin
+          retval       += self.page(current_page, options)
+          current_page += 1
+        end while Program.total > retval.size
+
+        retval
+      end
+
+      # Returns a list of programItems
+      #
+      # This is equivalent to the Zanox API method SearchPrograms.
+      # The method documentation can be found under {https://developer.zanox.com/web/guest/publisher-api-2011/get-programs}.
+      #
+      # Authentication: Requires connect ID.
+      #
+      # @param page [Integer] the page position
+      # @param per_page [Integer] number of items in the result set (API equivalent is items)
+      # @param items [Integer] number of items in the result set (API name)
+      # @param query [String] Limits results to programs associated with this search string (API equivalent is q).
+      # @param q [String] Limits results to programs associated with this search string (API name).
+      # @param start_date [Date] Limits results to programs activated after this date (API equivalent is startdate).
+      # @param startdate [Date] Limits results to programs activated after this date (API name).
+      # @param region [String] Limits results to a particular region.
+      # @param partnership [String] Limits results to programs with mandatory direct applications ("DIRECT") or not requiring direct application ("INDIRECT").
+      # @param has_products [Boolean] Limits results to programs with products (API equivalent is hasproducts).
+      # @param hasproducts [Boolean] Limits results to programs with products (API name).
+      #
+      # @return [Array<Program>]
+      def page(page = 0, options = {})
+        params = { query: { page: page } }
+
+        per_page = nil
+        per_page = options[:per_page] if per_page.nil?
+        per_page = options[:items]    if per_page.nil?
+        per_page = Program.per_page   if per_page.nil?
+        params[:query].merge!({ items: per_page })
+
+        q = options[:query]
+        q = options[:q]     if q.nil?
+
+        start_date = options[:start_date]
+        start_date = options[:startdate] if start_date.nil?
+        start_date = nil unless start_date.respond_to? :strftime
+        start_date = start_date.strftime('%Y-%m-%d') unless start_date.nil?
+
+        region = options[:region]
+
+        partnership = options[:partnership]
+
+        has_products = options[:has_products]
+        has_products = options[:hasproducts]  if has_products.nil?
+
+        params[:query].merge!({ q: q })                       unless q.nil?
+        params[:query].merge!({ startdate: start_date })      unless start_date.nil?
+        params[:query].merge!({ region: region })             unless region.nil?
+        params[:query].merge!({ partnership: partnership })   unless partnership.nil?
+        params[:query].merge!({ hasproducts: has_products })  unless has_products.nil?
+
+        retval = []
+
+        response = self.connection.get(RESOURCE_PATH, params)
+
+        Program.total = response.fetch('total')
+        programs = response.fetch('programItems', []).fetch('programItem', [])
+
+        programs.each do |program|
+          retval << Program.new(program)
+        end
+
+        retval
+      end
+
+      # Request an programItem by its ID.
+      #
+      # This is equivalent to the Zanox API method GetProgram.
+      # The method documentation can be found under {https://developer.zanox.com/web/guest/publisher-api-2011/get-programs-program}.
+      #
+      # Authentication: Requires connect ID.
+      #
+      # @param id [Program, Integer] the ID of the program you want to get.
+      #
+      # @return [<Program>]
+      def find(id)
+        response = self.connection.get(RESOURCE_PATH + "/program/#{id.to_i}")
+        progam = response.fetch('programItem', []).first
+
+        Program.new(progam)
+      end
+
+      # Get all program categories, including names and IDs, associated to the connect ID.
+      #
+      # This is equivalent to the Zanox API method GetProgramCategories.
+      # The method documentation can be found under {https://developer.zanox.com/web/guest/publisher-api-2011/get-programs-categories}.
+      #
+      # NOTE: These categories are different than ZanoxPublisher::Product::categories
+      #
+      # Authentication: Requires connect ID.
+      #
+      # @return [Array<Category>]
+      def categories
+        response = self.connection.get(RESOURCE_PATH + '/categories')
+        Category.fetch(response['categories'])
+      end
+
+      # A connection instance with Programs' relative_path
+      #
+      # @return [Connection]
+      def connection
+        @connection ||= Connection.new(RESOURCE_PATH)
+      end
+    end
+
+    # Retrieve AdMedia categories for this program.
+    #
+    # Returns a list of the advertiser-defined, program-specific ad media categories.
+    #
+    # This is equivalent to the Zanox API method GetAdmediumCategories.
+    # The method documentation can be found under {https://developer.zanox.com/web/guest/publisher-api-2011/get-admedia-categories-program}.
+    #
+    # NOTE: The returned ad media categories are different from progam categories
+    #
+    # Authentication: Requires connect ID.
+    #
+    # @return [Array<Category>]
+    def admedia_categories
+      response = Program.connection.get("/admedia/categories/program/#{@id}")
+
+      Category.fetch(response['categories'])
+    end
+
+    def initialize(data = {})
+      @id                   = data.fetch('@id').to_i
+
+      # Depending on short or long representation of object
+      if data.fetch('$', nil).nil?
+        @name                 = data.fetch('name')
+        @adrank               = data.fetch('adrank')
+        @application_required = data.fetch('applicationRequired')
+        @description          = data.fetch('description')
+        @description_local    = data.fetch('descriptionLocal', nil)
+        @products             = data.fetch('products')
+        @vertical             = data.fetch('vertical', nil)
+        @vertical             = Vertical.new(@vertical) unless @vertical.nil?
+        @regions              = data.fetch('regions', []).first
+        @regions              = @regions.fetch('region') unless @regions.nil?
+        @regions              = [@regions] if @regions.is_a? String
+        @categories           = data.fetch('categories', nil)
+        @categories           = Category.fetch(@categories) unless @categories.nil?
+        @start_date           = Date.strptime(data.fetch('startDate'), "%Y-%m-%dT%H:%M:%S%z")
+        @url                  = data.fetch('url')
+        @image                = data.fetch('image')
+        @currency             = data.fetch('currency')
+        @status               = data.fetch('status')
+        @terms                = data.fetch('terms', nil)
+        @terms_url            = data.fetch('termsUrl', nil)
+        @policies             = Policy.fetch(data['policies'])
+        @return_time_leads    = data.fetch('returnTimeLeads', nil)
+        @return_time_sales    = data.fetch('returnTimeSales', nil)
+      else
+        @name                 = data.fetch('$')
+      end
+    end
+
+    # Returns the programItems' ID as integer representation
+    #
+    # @return [Integer]
+    def to_i
+      @id
+    end
+
+    attr_accessor :id, :name, :adrank, :application_required, :description,
+                  :description_local, :products, :vertical, :regions, :categories,
+                  :start_date, :url, :image, :currency, :status, :terms, :terms_url,
+                  :policies, :return_time_leads, :return_time_sales
+
+    # make API names available
+    alias applicationRequired application_required
+    alias application_required? application_required
+    alias descriptionLocal description_local
+    alias startDate start_date
+    alias termsUrl terms_url
+    alias returnTimeLeads return_time_leads
+    alias returnTimeSales return_time_sales
+  end
+end

data/lib/zanox_publisher/program_application.rb

@@ -0,0 +1,135 @@
+module ZanoxPublisher
+  # Program Applications
+  #
+  # Apply to advertiser programs, get your applications, end partnerships.
+  #
+  # @attr [Integer]   id                  The programApplicationItems's identifer from Zanox
+  # @attr [Program]   program             The program for which the application is made
+  # @attr [AdSpace]   adspace             The ad space for which the application is made
+  # @attr [String]    status              The status of the application
+  # @attr [DateTime]  created_at          The date on which the application was created at
+  # @attr [Boolean]   allow_tpv           States if the application allows for tpv tracking links
+  # @attr [DateTime]  approved_date       The date on which the application was approved
+  # @attr [String]    publisher_comment   The publishers' comment on the application
+  # @attr [String]    advertiser_comment  The advertisers' comment on the application
+  class ProgramApplication < Base
+    RESOURCE_PATH = '/programapplications'
+
+    PROGRAM_APPLICATION_STATUS_ENUM = %w(open confirmed rejected deferred waiting blocked terminated canceled called declined deleted)
+
+    class << self
+      # Retrieves all program applications dependent on search parameters.
+      #
+      # NOTE: Program applications are still returned even after the advertiser program has been paused discontinued.
+      # The attribute "active" in the "program" element, indicates whether the program is still active.
+      #
+      # This is equivalent to the Zanox API method GetProgramApplications.
+      # The method documentation can be found under {https://developer.zanox.com/web/guest/publisher-api-2011/get-programapplications}.
+      #
+      # Authentication: Requires signature.
+      #
+      # This can require multiple requests, as internally every page is pulled.
+      # The ZanoxPublisher::ProgramApplication.page function can be used to better control the requests made.
+      #
+      # @param program [Program, Integer] Limits results to a particular program.
+      # @param adspace [AdSpace, Integer] Limits results to incentives that have tracking links associated with this ad space.
+      # @param status [String] Restrict results to program applications with certain status.
+      #
+      # @return [Array<ProgramApplication>]
+      def all(options = {})
+        retval = []
+        current_page = 0
+        options.merge!({ per_page: maximum_per_page })
+
+        begin
+          retval       += self.page(current_page, options)
+          current_page += 1
+        end while ProgramApplication.total > retval.size
+
+        retval
+      end
+
+      # Returns a list of programApplicationItems
+      #
+      # This is equivalent to the Zanox API method GetProgramApplications.
+      # The method documentation can be found under {https://developer.zanox.com/web/guest/publisher-api-2011/get-programapplications}.
+      #
+      # Authentication: Requires signature.
+      #
+      # @param page [Integer] the page position
+      # @param per_page [Integer] number of items in the result set (API equivalent is items)
+      # @param items [Integer] number of items in the result set (API name)
+      # @param program [Program, Integer] Limits results to a particular program.
+      # @param adspace [AdSpace, Integer] Limits results to incentives that have tracking links associated with this ad space.
+      # @param status [String] Restrict results to program applications with certain status.
+      #
+      # @return [Array<ProgramApplication>]
+      def page(page = 0, options = {})
+        params = { query: { page: page } }
+
+        per_page = nil
+        per_page = options[:per_page] if per_page.nil?
+        per_page = options[:items]    if per_page.nil?
+        per_page = Program.per_page   if per_page.nil?
+        params[:query].merge!({ items: per_page })
+
+        program = options[:program]
+        program = program.to_i      unless program.nil?
+
+        adspace = options[:adspace]
+        adspace = adspace.to_i      unless adspace.nil?
+
+        status  = options[:status]
+        status  = nil               unless PROGRAM_APPLICATION_STATUS_ENUM.include? status
+
+        params[:query].merge!({ program: program })  unless program.nil?
+        params[:query].merge!({ adspace: adspace })  unless adspace.nil?
+        params[:query].merge!({ status:  status  })  unless status.nil?
+
+        retval = []
+
+        response = self.connection.signature_get(RESOURCE_PATH, params)
+
+        ProgramApplication.total = response.fetch('total')
+        program_applications = response.fetch('programApplicationItems', {}).fetch('programApplicationItem', [])
+
+        program_applications.each do |application|
+          retval << ProgramApplication.new(application)
+        end
+
+        retval
+      end
+
+      # A connection instance with Program Applications' relative_path
+      #
+      # @return [Connection]
+      def connection
+        @connection ||= Connection.new(RESOURCE_PATH)
+      end
+    end
+
+    # TODO: {https://developer.zanox.com/web/guest/publisher-api-2011/post-programapplications-program-adspace}
+    # TODO: {https://developer.zanox.com/web/guest/publisher-api-2011/delete-programapplications-program-adspace}
+    def initialize(data = {})
+      @id                 = data.fetch('@id').to_i
+      @program            = Program.new(data.fetch('program'))
+      @adspace            = AdSpace.new(data.fetch('adspace'))
+      @status             = data.fetch('status')
+      @created_at         = data.fetch('createDate')
+      @allow_tpv          = data.fetch('allowTpv')
+      @approved_date      = data.fetch('approvedDate', nil)
+      @publisher_comment  = data.fetch('publisherComment', nil)
+      @advertiser_comment = data.fetch('advertiserComment', nil)
+    end
+
+    attr_accessor :id, :program, :adspace, :status, :created_at, :allow_tpv,
+                  :approved_date, :publisher_comment, :advertiser_comment
+
+    # make API names available
+    alias createDate created_at
+    alias allowTpv allow_tpv
+    alias approvedDate approved_date
+    alias publisherComment publisher_comment
+    alias advertiserComment advertiser_comment
+  end
+end

data/lib/zanox_publisher/tracking_link.rb

@@ -0,0 +1,42 @@
+module ZanoxPublisher
+  # @attr [Integer] adspace     The adspaces' ID for which the tracking link is set
+  # @attr [String]  ppv         The Pay Per View tracking link
+  # @attr [String]  ppc         The Pay Per Click tracking link
+  # @attr [String]  tpv         The True Post View tracking link
+  class TrackingLink
+    class << self
+      # Fetch all tracking links from Zanox API Response
+      #
+      # @param data [Array] the value of the 'trackingLinks' element
+      #
+      # @return [Array<TrackingLink>, nil]
+      def fetch(data = nil)
+        # To support API of picking categories of hash with [] notation
+        return nil if data.nil? or not data.respond_to? :each
+
+        retval = []
+
+        data.each do |tracking_link|
+          retval << TrackingLink.new(tracking_link)
+        end
+
+        retval
+      end
+    end
+    attr_reader :adspace, :ppv, :ppc
+
+    def initialize(data = {})
+      @adspace = data.fetch('@adspaceId').to_i
+      @ppv     = data.fetch('ppv')
+      @ppc     = data.fetch('ppc')
+      @tpv     = data.fetch('tpv', nil)
+    end
+
+    # Returns the adspaceItems' ID as integer representation
+    #
+    # @return [Integer]
+    def to_i
+      @adspace
+    end
+  end
+end

data/lib/zanox_publisher/version.rb

@@ -0,0 +1,3 @@
+module ZanoxPublisher
+  VERSION = "0.1.0"
+end

data/lib/zanox_publisher/vertical.rb

@@ -0,0 +1,19 @@
+module ZanoxPublisher
+  # Wrapper for the vertical response from Zanox API
+  class Vertical
+    attr_reader :id, :name
+
+    def initialize(data = {})
+      @id   = data.fetch('@id').to_i
+      @name = data.fetch('$')
+    end
+
+    def to_s
+      @name
+    end
+
+    def to_i
+      @id
+    end
+  end
+end

data/lib/zanox_publisher.rb

@@ -0,0 +1,39 @@
+require 'zanox_publisher/version'
+
+module ZanoxPublisher
+  autoload :Connection,         'zanox_publisher/connection'
+  autoload :Base,               'zanox_publisher/base'
+  autoload :Category,           'zanox_publisher/category'
+  autoload :Format,             'zanox_publisher/format'
+  autoload :Vertical,           'zanox_publisher/vertical'
+  autoload :Policy,             'zanox_publisher/policy'
+  autoload :Prize,              'zanox_publisher/prize'
+  autoload :TrackingLink,       'zanox_publisher/tracking_link'
+  autoload :Profile,            'zanox_publisher/profile'
+  autoload :AdSpace,            'zanox_publisher/ad_space'
+  autoload :AdMedium,           'zanox_publisher/ad_medium'
+  autoload :Product,            'zanox_publisher/product'
+  autoload :Program,            'zanox_publisher/program'
+  autoload :ProgramApplication, 'zanox_publisher/program_application'
+  autoload :IncentiveBase,      'zanox_publisher/incentive_base'
+  autoload :Incentive,          'zanox_publisher/incentive'
+  autoload :ExclusiveIncentive, 'zanox_publisher/exclusive_incentive'
+
+  class << self
+    attr_accessor :connect_id, :secret_key
+
+    # Setup connect ID and secret key for ZanoxPublisher.
+    # The connect ID and secret key will be used for all subsequent requests.
+    #
+    # @param connect_id [String] The connect ID of your account for authentication
+    # @param secret_key [String] The secret key of your account for authentication
+    #
+    # @example
+    #           ZanoxPublisher::authenticate("<your_client_id>", "<your_client_secret>")
+    #           ZanoxPublisher::Profile.first #=> <Profile>
+    #
+    def authenticate(connect_id, secret_key)
+      @connect_id, @secret_key = connect_id, secret_key
+    end
+  end
+end

data/spec/config/credentials.example.yml

@@ -0,0 +1,2 @@
+connect_id: 'your connection ID'
+secret_key: 'your secret key'

data/spec/lib/requirements_spec.rb

@@ -0,0 +1,9 @@
+describe "Test requirement", :focus do
+  it "a connect ID in spec/config/credentials.yml" do
+    expect(credentials['connect_id']).to be_kind_of String
+  end
+
+  it "a secret key in spec/config/credentials.yml" do
+    expect(credentials['secret_key']).to be_kind_of String
+  end
+end

data/spec/lib/zanox_publisher/ad_medium_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+describe ZanoxPublisher::AdMedium do
+  before(:all) { ZanoxPublisher::authenticate(credentials['connect_id'], credentials['secret_key']) }
+  after(:all) { ZanoxPublisher::authenticate(nil, nil) }
+
+  let(:program) { ZanoxPublisher::Program.page.first }
+  let(:category) { program.admedia_categories.first }
+  let(:region) { 'DE' }
+  let(:format) { 4 }
+  let(:type) { ZanoxPublisher::AdMedium.admedia_types.first }
+  let(:purpose_supported) { ZanoxPublisher::AdMedium.admedia_purposes[1] }
+  let(:purpose_unsupported) { ZanoxPublisher::AdMedium.admedia_purposes.last }
+  let(:partnership_direct) { 'DIRECT' }
+  let(:partnership_indirect) { 'INDIRECT' }
+  let(:adspace) { ZanoxPublisher::AdSpace.page.first }
+  let(:admedium_total) do
+    ZanoxPublisher::AdMedium.page
+    ZanoxPublisher::AdMedium.total
+  end
+
+  describe '::page', :vcr do
+    subject(:admedia) { ZanoxPublisher::AdMedium.page }
+
+    it { is_expected.to be_kind_of Array }
+    it { expect(admedia.first).to be_kind_of ZanoxPublisher::AdMedium }
+
+    it { expect(admedia.count).to be > 0 }
+    it 'to set the AdMedium total count' do
+      ZanoxPublisher::AdMedium.total = nil
+      admedia
+      expect(ZanoxPublisher::AdMedium.total).to be > 0
+    end
+
+    context 'with program', vcr: { record: :new_episodes } do
+      subject(:admedia) { ZanoxPublisher::AdMedium.page(0, { program: program }) }
+
+      it { expect(admedia.all? { |admedium| admedium.program.id == program.id }).to be true }
+    end
+
+    context 'with region', vcr: { record: :new_episodes } do
+      subject(:admedia) { ZanoxPublisher::AdMedium.page(0, { region: region }) }
+
+      it 'limits results to programs from a particular region' do
+        programs = []
+
+        admedia.each do |admedium|
+          program = ZanoxPublisher::Program.find(admedium.program.id)
+          programs << program
+        end
+
+        expect(programs.all? { |program| program.regions.include? region }).to be true
+      end
+    end
+
+    context 'with format' do
+      subject(:admedia) { ZanoxPublisher::AdMedium.page(0 , { format: format }) }
+
+      it { expect(admedia.all? { |admedium| admedium.format.id == format }).to be true }
+    end
+
+    context 'with admedium_type' do
+      subject(:admedia) { ZanoxPublisher::AdMedium.page(0, { admedium_type: type }) }
+
+      it { expect(admedia.all? { |admedium| admedium.admedium_type == type }).to be true }
+    end
+
+    context 'with admediumtype' do
+      subject(:admedia) { ZanoxPublisher::AdMedium.page(0, { admediumtype: type }) }
+
+      it { expect(admedia.all? { |admedium| admedium.admedium_type == type }).to be true }
+    end
+
+    context 'with purpose' do
+      subject(:admedia) { ZanoxPublisher::AdMedium.page(0, { purpose: purpose_supported }) }
+
+      # The response seems to nil purpose but does not error with unallowed request
+      it { expect(admedia.all? { |admedium| admedium.purpose == purpose_supported or admedium.purpose.nil? }).to be true}
+    end
+
+    context 'with unsupported purpose' do
+      subject { ZanoxPublisher::AdMedium.page(0, { purpose: purpose_unsupported }) }
+
+      it { expect{ subject }.to raise_error(ZanoxPublisher::BadRequest) }
+    end
+
+    context 'with partnership direct' do
+      subject(:admedia) { ZanoxPublisher::AdMedium.page(0, { partnership: partnership_direct }) }
+
+      # Seems to be effectless
+      it 'limits results to admedia with mandatory application' do
+        admedia
+        expect(ZanoxPublisher::AdMedium.total).to be <= admedium_total
+      end
+    end
+
+    context 'with partnership indirect' do
+      subject(:admedia) { ZanoxPublisher::AdMedium.page(0, { partnership: partnership_indirect }) }
+
+      # Seems to be effectless
+      it 'limits results to admedia without required application' do
+        admedia
+        expect(ZanoxPublisher::AdMedium.total).to be <= admedium_total
+      end
+    end
+
+    context 'with category' do
+      subject(:admedia) { ZanoxPublisher::AdMedium.page(0, { category: category })}
+
+      it { expect(admedia.all? { |admedium| admedium.category.id == category.id }).to be true }
+    end
+
+    context 'with adspace' do
+      subject(:admedia) { ZanoxPublisher::AdMedium.page(0, {adspace: adspace}) }
+
+      it 'incentives have tracking link associated with this AdSpace' do
+        expect(admedia.all? { |admedium| admedium.tracking_links.first.adspace == adspace.id}).to be true
+      end
+    end
+  end
+
+  describe '::all', :vcr do
+    subject(:admedia) { ZanoxPublisher::AdMedium.all region: region, admedium_type: type }
+
+    it { is_expected.to be_kind_of Array }
+    it { expect(admedia.first).to be_kind_of ZanoxPublisher::AdMedium }
+
+    it { expect(admedia.count).to be == ZanoxPublisher::AdMedium.total }
+  end
+
+  describe '::find', vcr: { record: :new_episodes } do
+    let(:first) do
+      ZanoxPublisher::AdMedium.page.first
+    end
+
+    subject(:find) { ZanoxPublisher::AdMedium.find(first.id) }
+
+    it { is_expected.to be_kind_of ZanoxPublisher::AdMedium }
+
+    it { expect(find.id).to be == first.id }
+    it { expect(find.name).to be == first.name }
+    it { expect(find.adrank).to be == first.adrank }
+    it { expect(find.admedium_type).to be == first.admedium_type }
+    it { expect(find.program.id).to be == first.program.id }
+
+    context 'with adspace' do
+      subject(:find) { ZanoxPublisher::AdMedium.find(first.id, adspace: adspace)}
+
+      it 'ad medium has tracking link associated with this AdSpace' do
+        expect(find.tracking_links.first.adspace).to be == adspace.id
+      end
+    end
+  end
+
+  describe 'item', :vcr do
+    subject(:admedium) { ZanoxPublisher::AdMedium.page.first }
+
+    it 'responds to to_i with its ID' do
+      expect(admedium.to_i).to be == admedium.id
+    end
+  end
+end