gladwords 1.0.1

data/spec/unit/commands/delete_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+RSpec.describe Gladwords::Commands::Delete do
+  include_context 'labels'
+
+  subject(:command) do
+    relation.command(:delete)
+  end
+
+  let(:service) { label_service }
+  let(:relation) { labels }
+
+  before do
+    allow(service).to receive(:get).and_return(entries: [{ id: '1' }])
+    allow(service).to receive(:mutate).and_return(value: [{ id: '1' }])
+  end
+
+  it 'mutates the service with the correct operations' do
+    expect(service).to receive(:mutate).with(
+      [
+        {
+          operator: 'REMOVE',
+          operand: { id: '1' }
+        }
+      ]
+    )
+
+    rel = relation.where(id: 1)
+    delete_command = rel.command(:delete)
+    delete_command.call
+  end
+end

data/spec/unit/commands/update_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+RSpec.describe Gladwords::Commands::Update do
+  include_context 'campaigns'
+
+  subject(:command) do
+    relation.command(:update)
+  end
+
+  let(:service) { campaign_service }
+  let(:relation) { campaigns }
+
+  context 'when provided a single tuple' do
+    before do
+      allow(service).to receive(:mutate).and_return(
+        value: [{ name: 'updated name', id: '1', end_date: '01012017' }]
+      )
+    end
+
+    it 'mutates the service with the correct operations' do
+      expect(service).to receive(:mutate).with(
+        [
+          {
+            operator: 'SET',
+            operand: {
+              name: 'updated name',
+              id: '1'
+            }
+          }
+        ]
+      )
+
+      subject.call(name: 'updated name', id: '1')
+    end
+
+    it 'returns a struct' do
+      result = subject.call(name: 'updated name', id: '1')
+
+      expect(result).to be_a(Gladwords::Struct::Campaign)
+      expect(result.id).to eq '1'
+      expect(result.name).to eq 'updated name'
+    end
+  end
+
+  context 'when provided multiple tuples' do
+    subject(:command) do
+      relation.command(:update, result: :many)
+    end
+
+    before do
+      allow(service).to(
+        receive(:mutate).and_return(
+          value: [
+            { name: 'updated name', id: '1', end_date: '01012017' },
+            { name: 'updated name 2', id: '2', end_date: '01012018' }
+          ]
+        )
+      )
+    end
+
+    it 'mutates the service with the correct operations' do
+      expect(service).to receive(:mutate).with(
+        [
+          {
+            operator: 'SET',
+            operand: {
+              name: 'updated name',
+              id: '1'
+            }
+          },
+          {
+            operator: 'SET',
+            operand: {
+              name: 'updated name 2',
+              id: '2'
+            }
+          }
+        ]
+      )
+
+      subject.call([{ name: 'updated name', id: '1' }, { name: 'updated name 2', id: '2' }])
+    end
+
+    it 'returns an array of structs' do
+      result = subject.call(
+        [{ name: 'updated name', id: '1' }, { name: 'updated name 2', id: '2' }]
+      )
+
+      expect(result.count).to eq 2
+
+      expect(result).to all be_a(Gladwords::Struct::Campaign)
+    end
+  end
+end

data/spec/unit/inflector_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe Gladwords::Inflector do
+  it 'correctly pluralizes criterion' do
+    expect(described_class.pluralize('criterion')).to eq 'criteria'
+  end
+
+  it 'correctly singularizes criteria' do
+    expect(described_class.singularize('criteria')).to eq 'criterion'
+  end
+end

data/spec/unit/relation/association_methods_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Gladwords
+  RSpec.describe Relation::AssociationMethods do
+    include_context 'campaigns'
+
+    context 'when the relation is one-to-many' do
+      subject { campaigns }
+
+      describe '#join' do
+        let(:campaign_id) { 1_338_164_832 }
+        let(:filtered_relation) { subject.select(:id).where(id: campaign_id).join(:ad_groups) }
+
+        it 'filters the target relation' do
+          returned_ids = filtered_relation.call.flat_map(&:ad_groups).map(&:campaign_id)
+
+          expect(returned_ids).to all eq(campaign_id)
+        end
+
+        it 'returns the filtered combined relationship' do
+          ad_groups = filtered_relation.ad_groups.call
+
+          aggregate_failures do
+            expect(ad_groups).to all be_a(Gladwords::Struct::AdGroup)
+            expect(ad_groups.pluck(:campaign_id)).to all eq(campaign_id)
+          end
+        end
+
+        it 'can query on the combined node' do
+          scope = filtered_relation.node(:ad_groups) { |n| n.select(:campaign_id) }
+          ad_group = scope.one.ad_groups.first
+          expect(ad_group.to_h).to eql(campaign_id: campaign_id)
+        end
+      end
+    end
+
+    context 'when the relation is many-to-one' do
+      subject { rom.relations[:ad_groups] }
+
+      describe '#combine' do
+        let(:campaign_id) { 1_338_164_832 }
+        let(:filtered_relation) { subject.combine(:campaign) }
+
+        it 'filters the target relation' do
+          scope = filtered_relation.where(campaign_id: campaign_id)
+          ad_group = scope.limit(1).call.one
+          expect(ad_group.campaign.id).to eql(campaign_id)
+        end
+
+        it 'can query on the combined node' do
+          scope = filtered_relation.where(campaign_id: campaign_id)
+          scope = scope.node(:campaign) { |n| n.select(:id) }
+          campaign = scope.call.one.campaign
+          expect(campaign.to_h).to eql(id: campaign_id)
+        end
+      end
+    end
+
+    context 'when the relation is has-many through' do
+      subject { campaigns }
+
+      describe '#combine' do
+        let(:campaign_id) { 1_338_164_832 }
+
+        context 'when the combine is nested' do
+          let(:filtered_relation) { subject.combine(ad_groups: [:ad_group_ads]) }
+
+          it 'includes the nested has_many through' do
+            scope = filtered_relation.where(campaign_id: campaign_id).one
+            ads = scope.ad_groups.flat_map(&:ad_group_ads)
+            expect(ads).not_to be_empty
+            expect(ads.map(&:base_campaign_id)).to all eq(campaign_id)
+          end
+        end
+
+        context 'when the combine is direct' do
+          let(:filtered_relation) { subject.combine(:ad_group_ads) }
+
+          it 'includes the nested has_many through' do
+            pending 'Combine is not working for direct has many through'
+            scope = filtered_relation.where(campaign_id: campaign_id).one
+
+            ads = scope.ad_group_ads
+            expect(ads).not_to be_empty
+            expect(ads.map(&:base_campaign_id)).to all eq(campaign_id)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/relation_spec.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+RSpec.describe Gladwords::Relation do
+  include_context 'campaigns'
+
+  subject { campaigns }
+
+  describe '#by_pk' do
+    it 'loads the resource by id and limits the result' do
+      new_scope = subject.by_pk('123')
+      predicates = new_scope.options.dig(:selector, :predicates)
+      paging = new_scope.options.dig(:selector, :paging)
+
+      expect(predicates).to eql([{ field: 'Id', operator: 'IN', values: ['123'] }])
+      expect(paging).to eql(number_results: 1)
+    end
+  end
+
+  describe '#where' do
+    it 'chains where clauses' do
+      old_scope = subject.select(:id, :name).where(id: '123')
+      new_scope = old_scope.where(name: 'TestName')
+      expected = [{ field: 'Id',   operator: 'IN', values: ['123'] },
+                  { field: 'Name', operator: 'IN', values: ['TestName'] }]
+      predicates = new_scope.options.dig(:selector, :predicates)
+
+      expect(predicates).to match_array(expected)
+    end
+
+    it 'de-duplicates where clauses' do
+      old_scope = subject.select(:id, :name).where(id: '123')
+      new_scope = old_scope.where(id: '123')
+      expected = [{ field: 'Id', operator: 'IN', values: ['123'] }]
+      predicates = new_scope.options.dig(:selector, :predicates)
+
+      expect(predicates).to match_array(expected)
+    end
+  end
+
+  describe '#total_count' do
+    it 'shows the total_count' do
+      scope = subject.select(:id, :name).where(name: 'Test Campaign 2')
+
+      expect(scope.total_count).to eq 1
+    end
+  end
+
+  describe '#offset' do
+    it 'offsets the start_index' do
+      scope = subject.offset(10)
+
+      expect(scope.options.dig(:selector, :paging, :start_index)).to eq 10
+    end
+  end
+
+  describe '#limit' do
+    it 'sets the paging[:number_results]' do
+      scope = subject.limit(3)
+
+      expect(scope.options.dig(:selector, :paging, :number_results)).to eq 3
+    end
+  end
+
+  describe '#select' do
+    it 'camelcases the fields' do
+      scope = subject.select(:base_campaign_id, :name)
+      fields = scope.options.dig(:selector, :fields)
+
+      expect(fields).to contain_exactly 'BaseCampaignId', 'Name'
+    end
+
+    it 'only selects unique fields' do
+      scope = subject.select(:name).select(:name)
+      fields = scope.options.dig(:selector, :fields)
+
+      expect(fields).to contain_exactly 'Name'
+    end
+
+    it 'limits requested fields when using #select' do
+      repo = Class.new(ROM::Repository[:campaigns]).new(rom)
+      result = repo.campaigns.select(:name).limit(1).one
+
+      expect(result.to_h.keys).to contain_exactly(:name)
+    end
+  end
+
+  describe '#pluck' do
+    it 'returns an array of the ids' do
+      ids = subject.pluck(:id).call
+
+      expect(ids).not_to be_empty
+      expect(ids).to all be_a(Integer)
+    end
+
+    it 'only requests the plucked field' do
+      expect(campaign_service)
+        .to receive(:get)
+        .with(a_hash_including(fields: ['Id']))
+        .and_return({})
+
+      scope = subject.pluck(:id)
+
+      expect(scope.options.dig(:selector, :fields)).to eql(['Id'])
+      scope.call
+    end
+  end
+
+  it 'by default selects all selectable fields' do
+    repo = Class.new(ROM::Repository[:campaigns]).new(rom)
+    scope = repo.campaigns.where(name: 'Test Campaign 2')
+    result = scope.call
+
+    expected = {
+      id: 1_338_164_832,
+      status: 'ENABLED',
+      serving_status: 'SERVING',
+      ad_serving_optimization_status: 'OPTIMIZE',
+      advertising_channel_type: 'SEARCH',
+      advertising_channel_sub_type: nil,
+      campaign_trial_type: 'BASE',
+      campaign_group_id: nil,
+      name: 'Test Campaign 2',
+      start_date: '20180329',
+      end_date: '20371230',
+      universal_app_campaign_info: nil,
+      final_url_suffix: nil,
+      budget: {
+        budget_id: 1_391_080_779,
+        name: 'Test Campaign 2',
+        amount: a_hash_including(micro_amount: 999_000_000),
+        delivery_method: 'STANDARD',
+        reference_count: 1,
+        is_explicitly_shared: false,
+        status: 'ENABLED'
+      },
+      conversion_optimizer_eligibility: {
+        eligible: false,
+        rejection_reasons: ['NOT_ENOUGH_CONVERSIONS']
+      },
+      frequency_cap: nil,
+      settings: [{
+        setting_type: 'GeoTargetTypeSetting',
+        positive_geo_target_type: 'LOCATION_OF_PRESENCE',
+        negative_geo_target_type: 'DONT_CARE',
+        xsi_type: 'GeoTargetTypeSetting'
+      }],
+      network_setting: {
+        target_google_search: true,
+        target_search_network: true,
+        target_content_network: false,
+        target_partner_search_network: false
+      },
+      labels: [],
+      bidding_strategy_configuration: {
+        bidding_strategy_id: nil,
+        bidding_strategy_name: nil,
+        bidding_strategy_type: 'MANUAL_CPC',
+        bidding_strategy_source: nil,
+        bidding_scheme: {
+          bidding_scheme_type: 'ManualCpcBiddingScheme',
+          enhanced_cpc_enabled: false,
+          xsi_type: 'ManualCpcBiddingScheme'
+        },
+        bids: [],
+        target_roas_override: nil
+      },
+      base_campaign_id: 1_338_164_832,
+      forward_compatibility_map: [],
+      tracking_url_template: nil,
+      url_custom_parameters: nil,
+      vanity_pharma: nil,
+      selective_optimization: nil
+    }
+
+    entries = result.map(&:to_h)
+
+    expect(entries.first).to match(expected)
+    expect(entries).to contain_exactly(expected)
+  end
+
+  describe '#request' do
+    it 'raises when the method does not exist' do
+      expect { subject.request(:bad_method) }
+        .to raise_error described_class::InvalidRequestMethodError
+    end
+  end
+end

data/spec/unit/schema/attributes_inferrer_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'adwords_api/v201809/campaign_service_registry'
+
+module Gladwords
+  RSpec.describe Schema::AttributesInferrer do
+    let(:schema) { double(name: :campaigns, options: { shitlist: [] }) }
+    let(:registry) { AdwordsApi::V201809::CampaignService::CampaignServiceRegistry }
+    let(:gateway) { double(service_registry: registry) }
+
+    describe '#call' do
+      declarations = {
+        String => %i[
+          name
+          status
+          serving_status
+          start_date
+          end_date
+          ad_serving_optimization_status
+          advertising_channel_type
+          advertising_channel_sub_type
+          campaign_trial_type
+          tracking_url_template
+          final_url_suffix
+        ],
+        Integer => %i[id base_campaign_id campaign_group_id]
+      }
+
+      declarations.each do |primitive, fields|
+        it "maps to #{primitive.name}", skip: fields.delete(skip: true) do
+          types, _missing = subject.call(schema, gateway)
+          attrs = types.select { |a| a.type.primitive == primitive }
+
+          expect(attrs.map(&:name)).to match_array(fields)
+        end
+      end
+
+      it 'maps nested types to hashes' do
+        types, _missing = subject.call(schema, gateway)
+        hash_field = types.find { |t| t.name == :budget }
+        member_types = hash_field.type.options[:member_types]
+
+        aggregate_failures do
+          expect(member_types[:budget_id].primitive).to eq(Integer)
+          expect(member_types[:name].primitive).to eq(String)
+        end
+      end
+
+      it 'includes read types for known nested hashes' do
+        types, _missing = subject.call(schema, gateway)
+        hash_field = types.find { |t| t.name == :budget }
+
+        read_type = hash_field.meta[:read]
+
+        expect(read_type).to be_a(Dry::Types::Constructor)
+      end
+
+      it 'removes shitlist attributes from schema' do
+        allow(schema).to receive(:options).and_return(shitlist: [:end_date])
+        types, _missing = subject.call(schema, gateway)
+
+        expect(types.find { |t| t.name == :end_date }).to be_nil
+      end
+
+      it 'created enumerated types' do
+        types, _missing = subject.call(schema, gateway)
+        status = types.find { |t| t.name == :status }
+        type = status.type
+
+        expect(type).to be_a(Dry::Types::Enum)
+        expect(type.options).to eql(values: %w[UNKNOWN ENABLED PAUSED REMOVED])
+      end
+
+      it 'creates enumerated type arrays' do
+        types, _missing = subject.call(schema, gateway)
+        status = types.find { |t| t.name == :conversion_optimizer_eligibility }
+        type = status.type.member_types[:rejection_reasons].type
+
+        expect(type).to be_a(Dry::Types::Array)
+      end
+    end
+  end
+end