txbr 1.0.0

data/lib/txbr/request_methods.rb

@@ -0,0 +1,45 @@
+module Txbr
+  module RequestMethods
+    private
+
+    def get_json(url, params = {})
+      response = get(url, params)
+      JSON.parse(response.body)
+    end
+
+    def post_json(url, body = {})
+      response = post(url, body.to_json)
+      JSON.parse(response.body)
+    end
+
+    def get(url, params = {})
+      act(:get, url, params)
+    end
+
+    def post(url, body)
+      act(:post, url, body)
+    end
+
+    def act(verb, *args)
+      connection.send(verb, *args).tap do |response|
+        raise_error!(response)
+      end
+    end
+
+    def raise_error!(response)
+      case response.status
+        when 401
+          raise BrazeUnauthorizedError, "401 Unauthorized: #{response.env.url}"
+        when 404
+          raise BrazeNotFoundError, "404 Not Found: #{response.env.url}"
+        else
+          if (response.status / 100) != 2
+            raise Txbr::BrazeApiError.new(
+              "HTTP #{response.status}: #{response.env.url}, body: #{response.body}",
+              response.status
+            )
+          end
+      end
+    end
+  end
+end

data/lib/txbr/strings_manifest.rb

@@ -0,0 +1,55 @@
+module Txbr
+  class StringsManifest
+    include Enumerable
+
+    def initialize
+      @strings ||= {}
+    end
+
+    def add(path, value)
+      root = path[0...-1].inject(@strings) do |ret, key|
+        ret[key] ||= {}
+      end
+
+      root[path.last] = value
+    end
+
+    def merge(other_manifest)
+      self.class.new.tap do |new_manifest|
+        new_manifest.merge!(self)
+        new_manifest.merge!(other_manifest)
+      end
+    end
+
+    def merge!(other_manifest)
+      other_manifest.each_string do |path, value|
+        add(path, value)
+      end
+    end
+
+    def to_h
+      @strings
+    end
+
+    def each(&block)
+      return to_enum(__method__) unless block_given?
+      each_helper(@strings, [], &block)
+    end
+
+    alias each_string each
+
+    private
+
+    def each_helper(root, path, &block)
+      case root
+        when Hash
+          root.each_pair do |key, child|
+            each_helper(child, path + [key], &block)
+          end
+
+        else
+          yield path, root
+      end
+    end
+  end
+end

data/lib/txbr/tasks.rb

@@ -0,0 +1,8 @@
+require 'rake'
+require 'txbr'
+
+namespace :txbr do
+  task :upload_all do
+    Txbr::Commands.upload_all
+  end
+end

data/lib/txbr/uploader.rb

@@ -0,0 +1,23 @@
+module Txbr
+  class Uploader
+    attr_reader :project
+
+    def initialize(project)
+      @project = project
+    end
+
+    def upload_all
+      project.handler.each_resource do |resource|
+        upload_resource(resource)
+      end
+    end
+
+    def upload_resource(resource)
+      stream = StringIO.new
+      resource.write_to(stream)
+      project.transifex_api.create_or_update(
+        resource.tx_resource, stream.string
+      )
+    end
+  end
+end

data/lib/txbr/utils.rb

@@ -0,0 +1,9 @@
+module Txbr
+  module Utils
+    def url_join(*segments)
+      segments.map { |s| s.sub(/\A\/|\/\z/, '') }.join('/')
+    end
+  end
+
+  Utils.extend(Utils)
+end

data/lib/txbr/version.rb

@@ -0,0 +1,3 @@
+module Txbr
+  VERSION = '1.0.0'
+end

data/spec/application_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe '/strings.json' do
+  include Rack::Test::Methods
+
+  def app
+    Txbr::Application
+  end
+
+  let(:api_client) { double(:api_client) }
+
+  let(:strings_format) { 'YML' }
+  let(:project_slug) { 'myproject' }
+  let(:resource_slug) { 'myresource' }
+  let(:locale) { 'en' }
+
+  before do
+    allow(Txbr::Config).to(
+      receive(:transifex_api_username).and_return('transifex_username')
+    )
+
+    allow(Txbr::Config).to(
+      receive(:transifex_api_password).and_return('transifex_password')
+    )
+
+    allow(Txgh::TransifexApi).to(
+      receive(:create_from_credentials).and_return(api_client)
+    )
+  end
+
+  it 'downloads the resource and returns a JSON version of it' do
+    expect(api_client).to(
+      receive(:download)
+        .with(project_slug, resource_slug, locale)
+        .and_return(YAML.dump(locale => { foo: { bar: { baz: 'boo' } } }))
+    )
+
+    params = {
+      locale: locale,
+      project_slug: project_slug,
+      resource_slug: resource_slug,
+      strings_format: strings_format
+    }
+
+    get '/strings.json', params
+
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq(
+      { foo: { bar: { baz: 'boo' } } }.to_json
+    )
+  end
+
+  it 'sends back an error response if a param is missing' do
+    get '/strings.json'
+    expect(last_response.status).to eq(400)
+    expect(JSON.parse(last_response.body)).to(
+      eq('error' => "Missing parameter 'project_slug'")
+    )
+  end
+
+  it 'sends back an error response if an unexpected error occurs' do
+    expect(api_client).to receive(:download).and_raise('jelly beans')
+
+    params = {
+      locale: locale,
+      project_slug: project_slug,
+      resource_slug: resource_slug,
+      strings_format: strings_format
+    }
+
+    get '/strings.json', params
+
+    expect(last_response.status).to eq(500)
+    expect(JSON.parse(last_response.body)).to(
+      eq('error' => 'jelly beans')
+    )
+  end
+end

data/spec/braze_session_api_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+require 'support/fake_braze_session'
+require 'support/fake_connection'
+
+describe Txbr::BrazeSessionApi do
+  let(:session_id) { 'session_id' }
+  let(:app_group_id) { 'app_group_id' }
+  let(:api_url) { 'https://somewhere.braze.com' }
+  let(:session) { FakeBrazeSession.new(api_url, session_id) }
+  let(:connection) { FakeConnection.new(interactions) }
+  let(:client) { described_class.new(session, app_group_id, connection: connection) }
+
+  shared_examples 'a client request that handles errors' do
+    context 'when the resource is not found' do
+      let(:interactions) do
+        super().tap do |inter|
+          inter[0][:response][:status] = 404
+        end
+      end
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(Txbr::BrazeNotFoundError)
+      end
+    end
+
+    context 'when the request is unauthorized' do
+      let(:interactions) do
+        super().tap do |inter|
+          inter.unshift(
+            request: inter[0][:request],
+            response: { status: 401 }
+          )
+        end
+      end
+
+      it 'resets the session and tries again' do
+        expect { subject }.to_not raise_error
+        expect(session).to be_reset
+      end
+    end
+
+    context 'when some other bad thing happens' do
+      let(:interactions) do
+        super().tap do |inter|
+          inter[0][:response][:status] = 500
+        end
+      end
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(Txbr::BrazeApiError)
+      end
+    end
+  end
+
+  describe '#each_email_template' do
+    before do
+      stub_const("#{described_class.name}::EMAIL_TEMPLATE_BATCH_SIZE", 1)
+    end
+
+    subject { client.each_email_template.to_a }
+
+    let(:interactions) do
+      [{
+        request: { verb: 'get', url: 'engagement/email_templates', start: 0, length: 1 },
+        response: { status: 200, body: { results: [{ id: '123abc' }] }.to_json }
+      }, {
+        request: { verb: 'get', url: 'engagement/email_templates', start: 1, length: 1 },
+        response: { status: 200, body: { results: [{ id: '456def' }] }.to_json }
+      }, {
+        request: { verb: 'get', url: 'engagement/email_templates', start: 2, length: 0 },
+        response: { status: 200, body: { results: [] }.to_json }
+      }]
+    end
+
+    it 'yields each template' do
+      expect(subject).to eq([{ 'id' => '123abc' }, { 'id' => '456def' }])
+    end
+
+    it_behaves_like 'a client request that handles errors'
+  end
+
+  describe '#get_email_template_details' do
+    subject { client.get_email_template_details(email_template_id: email_template_id) }
+    let(:email_template_id) { 'abc123' }
+
+    let(:details) do
+      {
+        'name' => 'Foo Template',
+        'template' => "<html><body>I'm a little teapot</body</html>",
+        'subject' => 'Subject subject',
+        'preheader' => 'Preheader preheader',
+      }
+    end
+
+    let(:interactions) do
+      [{
+        request: { verb: 'get', url: "engagement/email_templates/#{email_template_id}" },
+        response: { status: 200, body: details.to_json }
+      }]
+    end
+
+    it 'retrieves the template details' do
+      expect(subject).to eq(details)
+    end
+
+    it_behaves_like 'a client request that handles errors'
+  end
+end

data/spec/braze_session_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Txbr::BrazeSession do
+  # we need to hard-code this in order for VCR to successfully match requests
+  # after the initial recording
+  let(:api_url) { 'https://dashboard-03.braze.com' }
+
+  # NOTE: you will need to provide these env variables if you want to
+  # re-generate the VCR cassettes that depend on Braze login.
+  let(:email_address) { ENV['BRAZE_EMAIL_ADDRESS'] || 'BRAZE_EMAIL_ADDRESS' }
+  let(:password) { ENV['BRAZE_PASSWORD'] || 'BRAZE_PASSWORD' }
+
+  let(:session) { described_class.new(api_url, email_address, password) }
+
+  describe '#session_id' do
+    around do |example|
+      VCR.use_cassette('braze_login') { example.run }
+    end
+
+    it 'logs in and is issued a session id' do
+      expect(session.session_id).to match(/[a-z0-9]{32}/)
+    end
+
+    it 'does not create a new session if called more than once' do
+      # expect mechanize to be invoked exactly once
+      expect(Mechanize).to receive(:new).and_call_original.once
+
+      # grab the session ID multiple times, which should invoke
+      # mechanize the first time only
+      session.session_id
+      session.session_id
+    end
+  end
+
+  describe '#reset!' do
+    it 'causes a new session to be requested' do
+      # mechanize should be invoked twice, once before the session is reset
+      # and once after
+      expect(Mechanize).to receive(:new).and_call_original.twice
+
+      # we have to wrap the session_id calls in separate use_cassette calls
+      # because VCR isn't smart enough to stub the requests more than once
+      # (it would be great if cassettes had a "rewind" option, but alas)
+      VCR.use_cassette('braze_login') { session.session_id }
+      session.reset!
+      VCR.use_cassette('braze_login') { session.session_id }
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'tempfile'
+require 'yaml'
+
+require 'support/test_config'
+
+describe Txbr::Config do
+  before(:each) do
+    # clear out config before each test
+    Txbr::Config.instance_variable_set(:@raw_config, nil)
+  end
+
+  let(:config) { TestConfig.config }
+
+  shared_examples 'a successful configuration' do
+    it 'is configured correctly' do
+      expect(described_class.transifex_api_username).to eq('transifex_username')
+      expect(described_class.transifex_api_password).to eq('transifex_password')
+
+      expect(Txbr::Config.projects.size).to eq(1)
+      project = Txbr::Config.projects.first
+
+      expect(project.handler_id).to eq('email-templates')
+      expect(project.braze_api_key).to eq('braze_api_key')
+      expect(project.braze_api_url).to eq('https://somewhere.braze.com')
+      expect(project.strings_format).to eq('YML')
+      expect(project.source_lang).to eq('en')
+
+      # @TODO: remove once Braze implements the endpoints we asked for
+      expect(project.braze_email_address).to eq('braze@email.com')
+      expect(project.braze_password).to eq('braze_password')
+      expect(project.braze_app_group_id).to eq('5551212')
+    end
+  end
+
+  describe '.projects' do
+    context 'when config is specified as a string' do
+      around do |example|
+        with_env('TXBR_CONFIG' => "raw://#{YAML.dump(config)}") do
+          example.run
+        end
+      end
+
+      it_behaves_like 'a successful configuration'
+    end
+
+    context 'when config is specified as a file' do
+      let(:file) do
+        Tempfile.new('config').tap do |file|
+          file.write(YAML.dump(config))
+          file.flush
+        end
+      end
+
+      around do |example|
+        with_env('TXBR_CONFIG' => "file://#{file.path}") do
+          example.run
+        end
+      end
+
+      after do
+        file.close
+        file.unlink
+      end
+
+      it_behaves_like 'a successful configuration'
+    end
+  end
+end