txgh 1.0.0

data/lib/txgh/tx_logger.rb

@@ -0,0 +1,12 @@
+require 'logger'
+
+module Txgh
+  class TxLogger
+    def self.logger
+      @_logger ||= Logger.new(STDOUT).tap do |logger|
+        logger.level = Logger::INFO
+        logger.datetime_format = '%a %d-%m-%Y %H%M '
+      end
+    end
+  end
+end

data/lib/txgh/tx_resource.rb

@@ -0,0 +1,66 @@
+module Txgh
+  class TxResource
+    attr_reader :project_slug, :resource_slug, :type, :source_lang
+    attr_reader :source_file, :translation_file
+
+    alias_method :original_resource_slug, :resource_slug
+
+    def initialize(project_slug, resource_slug, type, source_lang, source_file,
+        lang_map, translation_file)
+      @project_slug = project_slug
+      @resource_slug = resource_slug
+      @type = type
+      @source_lang = source_lang
+      @source_file = source_file
+      @lang_map = {}
+
+      if lang_map
+        result = {}
+        lang_map.split(',').each do |m|
+          key_value = m.split(':', 2)
+          result[key_value[0].strip] = key_value[1].strip
+        end
+
+        @lang_map = result
+      end
+
+      @translation_file = translation_file
+    end
+
+    def L10N_resource_slug
+      "L10N#{resource_slug}"
+    end
+
+    def lang_map(tx_lang)
+      @lang_map.fetch(tx_lang, tx_lang)
+    end
+
+    def translation_path(language)
+      translation_file.gsub('<lang>', language)
+    end
+
+    def slugs
+      [project_slug, resource_slug]
+    end
+
+    def to_h
+      {
+        project_slug: project_slug,
+        resource_slug: resource_slug,
+        type: type,
+        source_lang: source_lang,
+        source_file: source_file,
+        translation_file: translation_file
+      }
+    end
+
+    def to_api_h
+      {
+        'slug' => resource_slug,
+        'i18n_type' => type,
+        'source_language_code' => source_lang,
+        'name' => translation_file
+      }
+    end
+  end
+end

data/lib/txgh/utils.rb

@@ -0,0 +1,44 @@
+module Txgh
+  module Utils
+    def slugify(str)
+      str.gsub('/', '_')
+    end
+
+    def absolute_branch(branch)
+      return unless branch
+      if is_tag?(branch)
+        branch
+      elsif branch.include?('heads/')
+        branch
+      else
+        "heads/#{branch}"
+      end
+    end
+
+    def is_tag?(ref)
+      ref.include?('tags/')
+    end
+
+    # Builds a hash from an array of hashes using a common key present in all
+    # the elements. For example, consider this array of hashes:
+    #
+    # arr = [
+    #   { 'param1' => 'dogs', 'param2' => 'hairy' },
+    #   { 'param1' => 'cats', 'param2' => 'fuzzy' }
+    # ]
+    #
+    # calling index_on('param1', arr) returns:
+    #
+    # {
+    #   'dogs' => { 'param1' => 'dogs', 'param2' => 'hairy' },
+    #   'cats' => { 'param1' => 'cats', 'param2' => 'fuzzy' }
+    # }
+    def index_on(key, arr)
+      arr.each_with_object({}) do |hash, ret|
+        ret[hash[key]] = hash
+      end
+    end
+  end
+
+  Utils.extend(Utils)
+end

data/lib/txgh/version.rb

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

data/spec/app_spec.rb

@@ -0,0 +1,346 @@
+require 'spec_helper'
+require 'rack/test'
+require 'uri'
+
+require 'helpers/github_payload_builder'
+require 'helpers/standard_txgh_setup'
+
+describe Txgh::Application do
+  include Rack::Test::Methods
+  include StandardTxghSetup
+
+  def app
+    Txgh::Application
+  end
+
+  describe '/health_check' do
+    it 'indicates the server is running, returns a 200' do
+      get '/health_check'
+      expect(last_response).to be_ok
+      expect(JSON.parse(last_response.body)).to eq({})
+    end
+  end
+
+  describe '/config' do
+    it 'fetches and returns the config for the given project' do
+      get '/config', project_slug: project_name
+      config = JSON.parse(last_response.body)['data']
+      expect(config).to include('resources')
+      expect(config).to_not include('branch_slug')
+      expect(config['resources'].first).to eq(
+        'project_slug' => 'my_awesome_project',
+        'resource_slug' => 'my_resource',
+        'type' => 'YML',
+        'source_lang' => 'en',
+        'source_file' => 'sample.yml',
+        'translation_file' => 'translations/<lang>/sample.yml'
+      )
+    end
+
+    it 'fetches and returns the config for the given project and branch' do
+      get '/config', project_slug: project_name, branch: branch
+      config = JSON.parse(last_response.body)['data']
+      expect(config).to include('resources')
+      expect(config['branch_slug']).to eq('heads_master')
+      expect(config['resources'].first).to eq(
+        'project_slug' => 'my_awesome_project',
+        'resource_slug' => 'my_resource',
+        'type' => 'YML',
+        'source_lang' => 'en',
+        'source_file' => 'sample.yml',
+        'translation_file' => 'translations/<lang>/sample.yml'
+      )
+    end
+
+    it "responds with not found when config can't be found" do
+      message = 'Red alert!'
+
+      expect(Txgh::Config::TxManager).to(
+        receive(:tx_config).and_raise(Txgh::ConfigNotFoundError, message)
+      )
+
+      get '/config', project_slug: project_name
+      expect(last_response.status).to eq(404)
+      response = JSON.parse(last_response.body)
+      expect(response).to eq([
+        'error' => message
+      ])
+    end
+
+    it 'responds with internal error when an unexpected error occurs' do
+      message = 'Red alert!'
+
+      expect(Txgh::Config::TxManager).to(
+        receive(:tx_config).and_raise(StandardError, message)
+      )
+
+      get '/config', project_slug: project_name
+      expect(last_response.status).to eq(500)
+      response = JSON.parse(last_response.body)
+      expect(response).to eq([
+        'error' => message
+      ])
+    end
+  end
+end
+
+describe Txgh::Hooks do
+  include Rack::Test::Methods
+  include StandardTxghSetup
+  include Txgh::ResponseHelpers
+
+  def app
+    Txgh::Hooks
+  end
+
+  let(:config) do
+    Txgh::Config::ConfigPair.new(project_config, repo_config)
+  end
+
+  before(:each) do
+    allow(Txgh::Config::KeyManager).to(
+      receive(:config_from_project).with(project_name).and_return(config)
+    )
+
+    allow(Txgh::Config::KeyManager).to(
+      receive(:config_from_repo).with(repo_name).and_return(config)
+    )
+  end
+
+  describe '/transifex' do
+    def sign_with(body)
+      header(
+        Txgh::TransifexRequestAuth::TRANSIFEX_HEADER,
+        Txgh::TransifexRequestAuth.header_value(
+          body, config.transifex_project.webhook_secret
+        )
+      )
+    end
+
+    let(:handler) { double(:handler) }
+
+    let(:params) do
+      {
+        'project' => project_name,
+        'resource' => resource_slug,
+        'language' => language,
+        'translated' => '100'
+      }
+    end
+
+    let(:payload) { URI.encode_www_form(params.to_a) }
+
+    before(:each) do
+      allow(Txgh::Handlers::Transifex::HookHandler).to(
+        receive(:new) do |options|
+          expect(options[:project].name).to eq(project_name)
+          expect(options[:repo].name).to eq(repo_name)
+          handler
+        end
+      )
+    end
+
+    it 'creates a handler and executes it' do
+      expect(handler).to(
+        receive(:execute).and_return(respond_with(200, true))
+      )
+
+      payload = URI.encode_www_form(params.to_a)
+      sign_with payload
+      post '/transifex', payload
+      expect(last_response).to be_ok
+    end
+
+    it 'returns unauthorized if not properly signed' do
+      post '/transifex', payload
+      expect(last_response.status).to eq(401)
+    end
+
+    it 'returns internal error on unexpected error' do
+      expect(Txgh::Config::KeyManager).to(
+        receive(:config_from_project).and_raise(StandardError)
+      )
+
+      sign_with payload
+      post '/transifex', payload
+      expect(last_response.status).to eq(500)
+      expect(JSON.parse(last_response.body)).to eq([
+        'error' => 'Internal server error: StandardError'
+      ])
+    end
+  end
+
+  describe '/github' do
+    def sign_with(body)
+      header(
+        Txgh::GithubRequestAuth::GITHUB_HEADER,
+        Txgh::GithubRequestAuth.header_value(
+          body, config.github_repo.webhook_secret
+        )
+      )
+    end
+
+    describe 'push event' do
+      let(:handler) { double(:handler) }
+
+      before(:each) do
+        allow(Txgh::Handlers::Github::PushHandler).to(
+          receive(:new) do |options|
+            expect(options[:project].name).to eq(project_name)
+            expect(options[:repo].name).to eq(repo_name)
+            handler
+          end
+        )
+      end
+
+      it 'forwards the request to the github request handler' do
+        expect(handler).to(
+          receive(:execute).and_return(respond_with(200, true))
+        )
+
+        payload = GithubPayloadBuilder.push_payload(repo_name, ref)
+
+        sign_with payload.to_json
+        header 'X-GitHub-Event', 'push'
+        post '/github', payload.to_json
+
+        expect(last_response).to be_ok
+      end
+
+      it 'returns unauthorized if not properly signed' do
+        payload = GithubPayloadBuilder.push_payload(repo_name, ref)
+
+        header 'X-GitHub-Event', 'push'
+        post '/github', payload.to_json
+
+        expect(last_response.status).to eq(401)
+      end
+
+      it 'returns invalid request if event unrecognized' do
+        header 'X-GitHub-Event', 'foobar'
+        post '/github'
+
+        expect(last_response.status).to eq(400)
+      end
+
+      it 'returns internal error on unexpected error' do
+        payload = GithubPayloadBuilder.push_payload(repo_name, ref)
+
+        expect(Txgh::Config::KeyManager).to(
+          receive(:config_from_repo).and_raise(StandardError)
+        )
+
+        header 'X-GitHub-Event', 'push'
+        post '/github', payload.to_json
+
+        expect(last_response.status).to eq(500)
+        expect(JSON.parse(last_response.body)).to eq([
+          'error' => 'Internal server error: StandardError'
+        ])
+      end
+    end
+  end
+end
+
+describe Txgh::Triggers do
+  include Rack::Test::Methods
+  include StandardTxghSetup
+
+  def app
+    Txgh::Triggers
+  end
+
+  let(:config) do
+    Txgh::Config::ConfigPair.new(project_config, repo_config)
+  end
+
+  before(:each) do
+    allow(Txgh::Config::KeyManager).to(
+      receive(:config_from_project).with(project_name).and_return(config)
+    )
+
+    allow(Txgh::Config::KeyManager).to(
+      receive(:config_from_repo).with(repo_name).and_return(config)
+    )
+  end
+
+  describe '/push' do
+    let(:params) do
+      { project_slug: project_name, resource_slug: resource_slug, branch: branch }
+    end
+
+    it 'updates the expected resource' do
+      updater = double(:updater)
+      expect(Txgh::ResourceUpdater).to receive(:new).and_return(updater)
+      expect(Txgh::GithubApi).to receive(:new).and_return(github_api)
+      expect(github_api).to receive(:get_ref).and_return(object: { sha: 'abc123' })
+
+      expect(updater).to receive(:update_resource) do |resource, sha|
+        expected_branch = Txgh::Utils.absolute_branch(branch)
+        expect(resource.branch).to eq(expected_branch)
+        expect(resource.project_slug).to eq(project_name)
+        expect(resource.resource_slug).to(
+          eq("#{resource_slug}-#{Txgh::Utils.slugify(expected_branch)}")
+        )
+      end
+
+      patch '/push', params
+      expect(last_response).to be_ok
+    end
+
+    it 'returns internal error on unexpected error' do
+      expect(Txgh::Config::KeyManager).to(
+        receive(:config_from_project).and_raise(StandardError)
+      )
+
+      patch '/push', params
+
+      expect(last_response.status).to eq(500)
+      expect(JSON.parse(last_response.body)).to eq([
+        { 'error' => 'Internal server error: StandardError' }
+      ])
+    end
+  end
+
+  describe '/pull' do
+    let(:params) do
+      { project_slug: project_name, resource_slug: resource_slug, branch: branch }
+    end
+
+    it 'updates translations (in all locales) in the expected repo' do
+      committer = double(:committer)
+      languages = [{ 'language_code' => 'pt' }, { 'language_code' => 'ja' }]
+      expect(Txgh::ResourceCommitter).to receive(:new).and_return(committer)
+      expect(Txgh::TransifexApi).to receive(:new).and_return(transifex_api)
+      expect(transifex_api).to receive(:get_languages).and_return(languages)
+
+      languages.each do |language|
+        expect(committer).to receive(:commit_resource) do |resource, branch, lang|
+          expect(branch).to eq(branch)
+          expect(lang).to eq(language['language_code'])
+          expect(resource.branch).to eq(branch)
+          expect(resource.project_slug).to eq(project_name)
+          expect(resource.resource_slug).to(
+            eq("#{resource_slug}-#{Txgh::Utils.slugify(branch)}")
+          )
+        end
+      end
+
+      patch '/pull', params
+      expect(last_response).to be_ok
+    end
+
+    it 'returns internal error on unexpected error' do
+      expect(Txgh::Config::KeyManager).to(
+        receive(:config_from_project).and_raise(StandardError)
+      )
+
+      patch '/pull', params
+
+      expect(last_response.status).to eq(500)
+      expect(JSON.parse(last_response.body)).to eq([
+        { 'error' => 'Internal server error: StandardError' }
+      ])
+    end
+  end
+end