txgh 5.3.4 → 5.4.0

data/lib/txgh/handlers/transifex/request_handler.rb

@@ -1,78 +0,0 @@
-require 'uri'
-
-module Txgh
-  module Handlers
-    module Transifex
-      class RequestHandler
-        class << self
-
-          def handle_request(request, logger)
-            new(request, logger).handle(Txgh::Handlers::Transifex::HookHandler)
-          end
-
-        end
-
-        include ResponseHelpers
-
-        attr_reader :request, :logger
-
-        def initialize(request, logger)
-          @request = request
-          @logger = logger
-        end
-
-        def handle(klass)
-          handle_safely do
-            handler = klass.new(
-              project: config.transifex_project,
-              repo: config.github_repo,
-              resource_slug: payload['resource'],
-              language: payload['language'],
-              logger: logger
-            )
-
-            handler.execute
-          end
-        end
-
-        private
-
-        def handle_safely
-          if authentic_request?
-            yield
-          else
-            respond_with_error(401, 'Unauthorized')
-          end
-        rescue => e
-          respond_with_error(500, "Internal server error: #{e.message}", e)
-        end
-
-        def authentic_request?
-          if project.webhook_protected?
-            TransifexRequestAuth.authentic_request?(
-              request, project.webhook_secret
-            )
-          else
-            true
-          end
-        end
-
-        def project
-          config.transifex_project
-        end
-
-        def config
-          @config ||= Txgh::Config::KeyManager.config_from_project(payload['project'])
-        end
-
-        def payload
-          @payload ||= begin
-            request.body.rewind
-            Hash[URI.decode_www_form(request.body.read)]
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/txgh/handlers/transifex.rb

@@ -1,8 +0,0 @@
-module Txgh
-  module Handlers
-    module Transifex
-      autoload :HookHandler,    'txgh/handlers/transifex/hook_handler'
-      autoload :RequestHandler, 'txgh/handlers/transifex/request_handler'
-    end
-  end
-end

data/lib/txgh/handlers/triggers/handler.rb

@@ -1,52 +0,0 @@
-module Txgh
-  module Handlers
-    module Triggers
-      class Handler
-
-        # includes response helpers in both the class and the singleton class
-        include ResponseHelpers
-
-        class << self
-          def handle_request(request, logger)
-            handle_safely do
-              config = Txgh::Config::KeyManager.config_from_project(
-                request.params.fetch('project_slug')
-              )
-
-              handler_for(config, request, logger).execute
-            end
-          end
-
-          private
-
-          def handle_safely
-            yield
-          rescue => e
-            respond_with_error(500, "Internal server error: #{e.message}", e)
-          end
-
-          def handler_for(config, request, logger)
-            new(
-              project: config.transifex_project,
-              repo: config.github_repo,
-              branch: request.params.fetch('branch'),
-              resource_slug: request.params.fetch('resource_slug'),
-              logger: logger
-            )
-          end
-        end
-
-        attr_reader :project, :repo, :branch, :resource_slug, :logger
-
-        def initialize(options = {})
-          @project = options[:project]
-          @repo = options[:repo]
-          @branch = Utils.absolute_branch(options[:branch])
-          @resource_slug = options[:resource_slug]
-          @logger = options[:logger]
-        end
-
-      end
-    end
-  end
-end

data/lib/txgh/handlers/triggers/pull_handler.rb

@@ -1,20 +0,0 @@
-module Txgh
-  module Handlers
-    module Triggers
-      class PullHandler < Handler
-
-        def execute
-          puller.pull_slug(resource_slug)
-          respond_with(200, true)
-        end
-
-        private
-
-        def puller
-          @puller ||= Txgh::Puller.new(project, repo, branch)
-        end
-
-      end
-    end
-  end
-end

data/lib/txgh/handlers/triggers/push_handler.rb

@@ -1,20 +0,0 @@
-module Txgh
-  module Handlers
-    module Triggers
-      class PushHandler < Handler
-
-        def execute
-          pusher.push_slug(resource_slug)
-          respond_with(200, true)
-        end
-
-        private
-
-        def pusher
-          @pusher ||= Txgh::Pusher.new(project, repo, branch)
-        end
-
-      end
-    end
-  end
-end

data/lib/txgh/handlers/triggers.rb

@@ -1,9 +0,0 @@
-module Txgh
-  module Handlers
-    module Triggers
-      autoload :Handler,     'txgh/handlers/triggers/handler'
-      autoload :PullHandler, 'txgh/handlers/triggers/pull_handler'
-      autoload :PushHandler, 'txgh/handlers/triggers/push_handler'
-    end
-  end
-end

data/lib/txgh/handlers/zip_stream_response.rb

@@ -1,21 +0,0 @@
-require 'ext/zipline/output_stream'
-
-module Txgh
-  module Handlers
-    class ZipStreamResponse < StreamResponse
-
-      def write_to(stream)
-        Zipline::OutputStream.open(stream) do |zipfile|
-          enum.each do |file_name, contents|
-            zipfile.put_next_entry(file_name, contents.bytesize)
-            zipfile << contents
-          end
-        end
-      end
-
-      def file_extension
-        '.zip'
-      end
-    end
-  end
-end

data/lib/txgh/handlers.rb

@@ -1,12 +0,0 @@
-module Txgh
-  module Handlers
-    autoload :DownloadHandler,   'txgh/handlers/download_handler'
-    autoload :Github,            'txgh/handlers/github'
-    autoload :Response,          'txgh/handlers/response'
-    autoload :StreamResponse,    'txgh/handlers/stream_response'
-    autoload :TgzStreamResponse, 'txgh/handlers/tgz_stream_response'
-    autoload :Transifex,         'txgh/handlers/transifex'
-    autoload :Triggers,          'txgh/handlers/triggers'
-    autoload :ZipStreamResponse, 'txgh/handlers/zip_stream_response'
-  end
-end

data/lib/txgh/transifex_request_auth.rb

@@ -1,53 +0,0 @@
-require 'openssl'
-
-module Txgh
-  class TransifexRequestAuth
-    HMAC_DIGEST = OpenSSL::Digest.new('sha1')
-    RACK_HEADER = 'HTTP_X_TX_SIGNATURE'
-    TRANSIFEX_HEADER = 'X-TX-Signature'
-
-    class << self
-      def authentic_request?(request, secret)
-        request.body.rewind
-        expected_signature = header_value(request.body.read, secret)
-        actual_signature = request.env[RACK_HEADER]
-        actual_signature == expected_signature
-      end
-
-      def header_value(content, secret)
-        digest(transform(content), secret)
-      end
-
-      private
-
-      # In order to generate a correct HMAC hash, the request body must be
-      # parsed and made to look like a python map. If you're thinking that's
-      # weird, you're correct, but it's apparently expected behavior.
-      def transform(content)
-        params = URI.decode_www_form(content)
-
-        params = params.map do |key, val|
-          key = "'#{key}'"
-          val = interpret_val(val)
-          "#{key}: #{val}"
-        end
-
-        "{#{params.join(', ')}}"
-      end
-
-      def interpret_val(val)
-        if val =~ /\A[\d]+\z/
-          val
-        else
-          "u'#{val}'"
-        end
-      end
-
-      def digest(content, secret)
-        Base64.encode64(
-          OpenSSL::HMAC.digest(HMAC_DIGEST, secret, content)
-        ).strip
-      end
-    end
-  end
-end

data/spec/app_spec.rb

@@ -1,347 +0,0 @@
-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' }]
-      project_config['languages'] = %w(pt 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

data/spec/github_request_auth_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-require 'rack'
-
-include Txgh
-
-describe GithubRequestAuth do
-  let(:secret) { 'abc123' }
-  let(:params) { '{"param1":"value1","param2":"value2","param3":123}' }
-  let(:valid_signature) { 'ea62c3f65c8e42f155d96a25b7ba6eb5d320630e' }
-
-  describe '.authentic_request?' do
-    it 'returns true if the request is signed correctly' do
-      request = Rack::Request.new(
-        GithubRequestAuth::RACK_HEADER => "sha1=#{valid_signature}",
-        'rack.input' => StringIO.new(params)
-      )
-
-      authentic = GithubRequestAuth.authentic_request?(request, secret)
-      expect(authentic).to eq(true)
-    end
-
-    it 'returns false if the request is not signed correctly' do
-      request = Rack::Request.new(
-        GithubRequestAuth::RACK_HEADER => 'incorrect',
-        'rack.input' => StringIO.new(params)
-      )
-
-      authentic = GithubRequestAuth.authentic_request?(request, secret)
-      expect(authentic).to eq(false)
-    end
-  end
-
-  describe '.header' do
-    it 'calculates the signature and formats it as an http header' do
-      value = GithubRequestAuth.header_value(params, secret)
-      expect(value).to eq("sha1=#{valid_signature}")
-    end
-  end
-end