gladwords 1.0.1

data/lib/gladwords/struct.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'rom/struct'
+
+# For now we override this because adwords does not always return all the
+# key-value pairs they say they will. This setting allows for that to happen
+# without throwing an error.
+#
+# For more info: http://dry-rb.org/gems/dry-struct/constructor-types/
+if ROM::Struct.respond_to?(:constructor_type) # rubocop:disable Style/GuardClause
+  ROM::Struct.constructor_type :schema
+else
+  raise <<~MSG
+    Dry::Struct.constructor_type has been deprecated in v0.5.0, info how to fix is here:
+    http://dry-rb.org/gems/dry-struct/constructor-types/
+  MSG
+end
+
+module Gladwords
+  # @api public
+  class Struct < ROM::Struct
+    constructor_type :schema
+  end
+end

data/lib/gladwords/types.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Gladwords
+  # @api private
+  module Types
+    include ROM::Types
+
+    def self.type(**meta)
+      yield(meta).meta(meta)
+    end
+
+    ID = Types::Int
+
+    Date = type(format: '%Y%m%d') do |format:|
+      read = Types.Constructor(::Date) { |d| ::Date.strptime(d, format) }
+
+      Types::String.meta(read: read)
+    end
+
+    Statuses = Types::Strict::String.enum(
+      'UNKNOWN',
+      'ENABLED',
+      'PAUSED',
+      'REMOVED'
+    )
+  end
+end

data/lib/gladwords/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Gladwords
+  VERSION = '1.0.1'
+end

data/rakelib/generate_selector_fields_db.rake

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'pry'
+require 'nokogiri'
+require 'json'
+require 'open-uri'
+require 'gladwords'
+
+def build_row(fields, values)
+  hash = Hash[fields.zip(values)]
+  hash.delete(:path)
+
+  { **hash, filterable: hash[:filterable] == 'Yes' }
+end
+
+adwords_versions = Gladwords.supported_versions.map(&:to_s)
+
+task :generate_selector_fields_db do
+  inflector = Gladwords::Inflector
+  url = 'https://developers.google.com/adwords/api/docs/appendix/selectorfields'
+
+  adwords_versions.each do |adwords_version|
+    puts "-> Generating db for #{adwords_version} from #{url}"
+
+    # rubocop:disable Security/Open
+    selectable_fields_docs = open(url)
+    # rubocop:enable Security/Open
+
+    page = Nokogiri::HTML(selectable_fields_docs).css('.devsite-article-body')
+    tables = page.css('table')
+
+    result = {}
+
+    tables.each do |table|
+      service_name_node = table
+
+      service_name_node = service_name_node.previous_sibling until service_name_node.text =~ /\w+Service$/
+
+      unless service_name_node.attributes['id'].value.start_with?(adwords_version)
+        next
+      end
+
+      service_name = inflector.underscore(service_name_node.text)
+      service_name = service_name.gsub('_service', '')
+      service_name = inflector.pluralize(service_name)
+      service_name = service_name.to_sym
+
+      result[service_name] ||= {}
+
+      fields = table.css('tr > th').map(&:text).map(&:downcase).map(&:to_sym)
+      rows = table.css('tr')[1..-1]
+      row_fields = rows.map do |row|
+        values = row.css('td').map(&:text).map(&:strip)
+        build_row(fields, values)
+      end
+
+      method = table.previous_sibling.previous_sibling.text.gsub('()', '')
+      method = inflector.underscore(method).to_sym
+      result[service_name][method] = row_fields
+    end
+
+    outfile = "lib/gladwords/selector_fields_db/#{adwords_version}.json"
+
+    File.open(outfile, 'w+') do |file|
+      file.write JSON.pretty_generate(result)
+    end
+
+    puts "-> Printed to #{outfile}"
+  end
+
+  puts '-> Done!'
+end

data/spec/integration/commands/create_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.describe Gladwords::Commands::Create do
+  include_context 'labels'
+
+  subject(:command) do
+    relation.command(:create)
+  end
+
+  let(:service) { label_service }
+  let(:relation) { labels }
+
+  it 'creates a label' do
+    name = SecureRandom.hex
+
+    subject.call(name: name, xsi_type: 'TextLabel')
+
+    rel = relation.where(label_name: name)
+
+    expect(rel.first[:name]).to eq name
+
+    rel.command(:delete).call
+  end
+end

data/spec/integration/commands/delete_spec.rb

@@ -0,0 +1,47 @@
+# 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 }
+
+  it 'deletes the label' do
+    label = relation.command(:create).call(name: SecureRandom.hex, xsi_type: 'TextLabel')
+
+    rel = relation.where(label_id: label.id).limit(1)
+    expect(rel.first[:status]).to eq 'ENABLED'
+
+    delete_command = rel.command(:delete)
+    delete_command.call
+
+    expect(rel.with({}).call.first[:status]).to eq 'REMOVED'
+  end
+
+  it 'deletes multiple labels' do
+    label, label2 = relation.command(:create, result: :many).call(
+      [
+        { name: SecureRandom.hex, xsi_type: 'TextLabel' },
+        { name: SecureRandom.hex, xsi_type: 'TextLabel' }
+      ]
+    )
+
+    rel = relation.where(label_id: [label.id, label2.id])
+                  .limit(2)
+
+    delete_command = rel.command(:delete)
+    delete_command.call
+
+    labels = rel.with({}).call
+
+    expect(labels.count).to eq 2
+
+    labels.each do |lab|
+      expect(lab[:status]).to eq 'REMOVED'
+    end
+  end
+end

data/spec/integration/commands/update_spec.rb

@@ -0,0 +1,24 @@
+# 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 }
+
+  it 'updates the campaign name' do
+    campaign = relation.select(:id, :name).first
+    name = SecureRandom.hex
+
+    subject.call(id: campaign[:id], name: name)
+
+    campaign = relation.select(:id, :name).first
+    expect(campaign[:name]).to eq name
+  end
+end

data/spec/shared/campaigns.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+RSpec.shared_context 'campaigns' do
+  let(:client) { gimme_adwords }
+  let(:configuration) do
+    ROM::Configuration.new(:adwords, client: client) do |config|
+      config.relation(:campaigns) do
+        auto_struct(true)
+        auto_map(true)
+
+        schema(infer: true) do
+          attribute :id, Gladwords::Types::ID
+
+          primary_key :id
+
+          associations do
+            has_many :ad_groups, combine_key: :campaign_id
+            has_many :ad_group_ads, through: :ad_groups
+            # , combine_key: :ad_group_id, foreign_key: :base_campaign_id
+          end
+        end
+      end
+
+      config.relation(:ad_groups) do
+        auto_struct(true)
+        auto_map(true)
+
+        schema(infer: true) do
+          attribute :id, Gladwords::Types::ID
+
+          primary_key :id
+
+          associations do
+            belongs_to :campaign, combine_key: :id
+            has_many :ad_group_ads, combine_key: :ad_group_id
+          end
+        end
+      end
+
+      config.relation(:ad_group_ads) do
+        auto_struct(true)
+        auto_map(true)
+
+        schema(infer: true) do
+          associations do
+            belongs_to :ad_group
+            has_one :campaign, through: :ad_groups
+          end
+        end
+      end
+    end
+  end
+  let(:rom) { ROM.container(configuration) }
+  let(:campaign_service) { rom.gateways[:default].dataset(:campaigns) }
+  let(:campaigns) { rom.relations[:campaigns] }
+end

data/spec/shared/labels.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+RSpec.shared_context 'labels' do
+  let(:client) { gimme_adwords }
+  let(:configuration) do
+    ROM::Configuration.new(:adwords, client: client) do |config|
+      config.relation(:labels) do
+        auto_struct(true)
+
+        schema(infer: true)
+      end
+    end
+  end
+  let(:rom) { ROM.container(configuration) }
+  let(:label_service) { rom.gateways[:default].dataset(:labels) }
+  let(:labels) { rom.relations[:labels] }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'gladwords'
+require 'adwords_api'
+require 'pry'
+
+root = Pathname(__FILE__).dirname
+
+Dir[root.join('{shared,support}/**/*.rb')].each { |f| require f }
+Dir[root.join('shared/**/*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  config.include AdwordsHelpers
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.disable_monkey_patching!
+  config.filter_run_when_matching :focus
+  config.example_status_persistence_file_path = 'tmp/examples.txt'
+  config.order = :random
+  config.formatter = :documentation
+  Kernel.srand config.seed
+end

data/spec/support/adwords_helpers.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module AdwordsApi
+  class Api
+    def freeze(*_args)
+      true
+    end
+  end
+end
+
+module AdwordsHelpers
+  # This is a test account, i.e. no real ad spend
+  API_CONFIG = {
+    authentication: {
+      method: 'OAuth2',
+      oauth2_client_id: '191191759012-uflljs7ckudnq4pl14lrkogkej2rodvm' \
+                        '.apps.googleusercontent.com',
+      oauth2_client_secret: 'zDil4XMnvtjeQqBpbJVEbS7d',
+      developer_token: 'rLHiiXnn-XSm4AwE8Ni6Tw',
+      client_customer_id: '9919697176',
+      user_agent: 'gladwords',
+      oauth2_token: {
+        refresh_token: '1/QEmJJudQcsw8CMfBU2VDZrhJaRVKQ8TjdVkvRYuZgFg',
+        expires_in: 0
+      }
+    },
+    service: {
+      environment: 'PRODUCTION'
+    }
+  }.freeze
+
+  def gimme_adwords
+    @gimme_adwords ||= begin
+                         adwords = AdwordsApi::Api.new(API_CONFIG)
+                         if Dir.exist?('log')
+                           adwords.logger = Logger.new('log/test.log')
+                         end
+                         adwords
+                       end
+  end
+end

data/spec/unit/commands/create_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+RSpec.describe Gladwords::Commands::Create do
+  include_context 'labels'
+
+  subject(:command) do
+    relation.command(:create)
+  end
+
+  let(:service) { label_service }
+  let(:relation) { labels }
+
+  context 'when provided a single tuple' do
+    before do
+      allow(service).to receive(:mutate).and_return(value: [{ name: 'test', id: '1' }])
+    end
+
+    it 'mutates the service with the correct operations' do
+      expect(service).to receive(:mutate).with(
+        [
+          {
+            operator: 'ADD',
+            operand: {
+              name: 'test',
+              id: '1'
+            }
+          }
+        ]
+      )
+
+      subject.call(name: 'test', id: '1')
+    end
+
+    it 'returns a struct' do
+      result = subject.call(name: 'test', id: '1')
+
+      expect(result).to be_a(Gladwords::Struct::Label)
+      expect(result.id).to eq '1'
+      expect(result.name).to eq 'test'
+    end
+  end
+
+  context 'when provided multiple tuples' do
+    subject(:command) do
+      relation.command(:create, result: :many)
+    end
+
+    before do
+      allow(service).to(
+        receive(:mutate).and_return(value: [{ name: 'foo', id: '1' }, { name: 'bar', id: '2' }])
+      )
+    end
+
+    it 'mutates the service with the correct operations' do
+      expect(service).to receive(:mutate).with(
+        [
+          {
+            operator: 'ADD',
+            operand: {
+              name: 'foo',
+              id: '1'
+            }
+          },
+          {
+            operator: 'ADD',
+            operand: {
+              name: 'bar',
+              id: '2'
+            }
+          }
+        ]
+      )
+
+      subject.call([{ name: 'foo', id: '1' }, { name: 'bar', id: '2' }])
+    end
+
+    it 'returns an array of structs' do
+      result = subject.call([{ name: 'foo', id: '1' }, { name: 'bar', id: '2' }])
+
+      expect(result.count).to eq 2
+
+      expect(result).to all be_a(Gladwords::Struct::Label)
+    end
+  end
+end