txgh-server 1.0.0.beta1

data/spec/application_spec.rb

@@ -0,0 +1,347 @@
+require 'spec_helper'
+require 'rack/test'
+require 'uri'
+
+require 'helpers/github_payload_builder'
+require 'helpers/standard_txgh_setup'
+
+describe TxghServer::Application do
+  include Rack::Test::Methods
+  include StandardTxghSetup
+
+  def app
+    TxghServer::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 TxghServer::WebhookEndpoints do
+  include Rack::Test::Methods
+  include StandardTxghSetup
+  include TxghServer::ResponseHelpers
+
+  def app
+    TxghServer::WebhookEndpoints
+  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(
+        TxghServer::TransifexRequestAuth::TRANSIFEX_HEADER,
+        TxghServer::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(TxghServer::Webhooks::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(
+        TxghServer::GithubRequestAuth::GITHUB_HEADER,
+        TxghServer::GithubRequestAuth.header_value(
+          body, config.github_repo.webhook_secret
+        )
+      )
+    end
+
+    describe 'push event' do
+      let(:handler) { double(:handler) }
+
+      before(:each) do
+        allow(TxghServer::Webhooks::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 TxghServer::TriggerEndpoints do
+  include Rack::Test::Methods
+  include StandardTxghSetup
+
+  def app
+    TxghServer::TriggerEndpoints
+  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/download_handler_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'helpers/standard_txgh_setup'
+require 'yaml'
+
+include TxghServer
+
+describe DownloadHandler do
+  include StandardTxghSetup
+
+  let(:format) { DownloadHandler::DEFAULT_FORMAT }
+
+  let(:params) do
+    {
+      'format' => format,
+      'project_slug' => project_name,
+      'branch' => ref
+    }
+  end
+
+  context '.handle_request' do
+    let(:request) do
+      double(:request).tap do |dbl|
+        allow(dbl).to receive(:params).and_return(params)
+        allow(dbl).to receive(:env).and_return(env)
+      end
+    end
+
+    let(:env) do
+      { 'REQUEST_PATH' => "path/to/#{project_name}#{format}" }
+    end
+
+    it 'responds with a streaming zip and has the project name as the attachment' do
+      response = DownloadHandler.handle_request(request)
+      expect(response).to be_streaming
+      expect(response).to be_a(ZipStreamResponse)
+      expect(response.attachment).to eq(project_name)
+    end
+
+    context 'with a tgz format specified' do
+      let(:format) { '.tgz' }
+
+      it 'responds with a streaming tgz download' do
+        response = DownloadHandler.handle_request(request)
+        expect(response).to be_streaming
+        expect(response).to be_a(TgzStreamResponse)
+      end
+    end
+
+    context 'when an error occurs' do
+      before(:each) do
+        expect(request).to receive(:params).and_raise(StandardError)
+        response = DownloadHandler.handle_request(request)
+        expect(response).to_not be_streaming
+        expect(response.status).to eq(500)
+      end
+    end
+  end
+
+  context '#execute' do
+    let(:handler) do
+      DownloadHandler.new(transifex_project, github_repo, params, logger)
+    end
+
+    it 'responds with a streaming zip download' do
+      expect(handler.execute).to be_a(ZipStreamResponse)
+    end
+
+    it 'responds with the project name as the attachment' do
+      response = handler.execute
+      expect(response.attachment).to eq(project_name)
+    end
+
+    context 'with a tgz format specified' do
+      let(:format) { '.tgz' }
+
+      it 'responds with a streaming tgz download' do
+        expect(handler.execute).to be_a(TgzStreamResponse)
+      end
+    end
+
+    context 'with a set of languages' do
+      let(:supported_languages) { %w(is fr) }
+
+      it "downloads translations for the project's supported languages" do
+        allow(transifex_api).to receive(:download)
+        files = handler.execute.enum.to_a.map(&:first)
+        expect(files).to eq(%w(translations/is/sample.yml translations/fr/sample.yml))
+      end
+    end
+  end
+end

data/spec/github_request_auth_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'rack'
+
+include TxghServer
+
+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

data/spec/helpers/github_payload_builder.rb

@@ -0,0 +1,141 @@
+require 'json'
+
+class GithubPayloadBuilder
+  class << self
+    def push_payload(*args)
+      GithubPushPayload.new(*args)
+    end
+
+    def delete_payload(*args)
+      GithubDeletePayload.new(*args)
+    end
+  end
+end
+
+class GithubPayload
+  def to_h
+    # convert symbolized keys to strings
+    JSON.parse(to_json)
+  end
+
+  def to_json
+    @result.to_json
+  end
+
+  protected
+
+  def digits
+    @@digits ||= ('a'..'f').to_a + ('0'..'9').to_a
+  end
+
+  def generate_timestamp
+    Time.now.strftime('%Y-%m-%dT%H:%M:%S%:z')
+  end
+
+  def generate_sha
+    blank_commit_id.gsub(/0/) { digits.sample }
+  end
+
+  def blank_commit_id
+    '0' * 40
+  end
+end
+
+class GithubDeletePayload < GithubPayload
+  attr_reader :repo, :ref
+
+  def initialize(repo, ref)
+    @repo = repo
+    @ref = ref
+
+    @result = {
+      ref: "refs/#{ref}",
+      ref_type: 'branch',
+      pusher_type: 'user',
+
+      repository: {
+        name: repo.split('/').last,
+        full_name: repo,
+        owner: {
+          login: repo.split('/').first
+        }
+      },
+
+      sender: {
+        login: repo.split('/').first,
+        type: 'User'
+      }
+    }
+  end
+end
+
+class GithubPushPayload < GithubPayload
+  attr_reader :repo, :ref, :before, :after
+
+  DEFAULT_USER = {
+    name: 'Test User',
+    email: 'test@user.com',
+    username: 'testuser'
+  }
+
+  def initialize(repo, ref, before = nil, after = nil)
+    @repo = repo
+    @ref = ref
+    @before = before || blank_commit_id
+    @after = after || generate_sha
+
+    @result = {
+      ref: "refs/#{ref}",
+      before: @before,
+      after: @after,
+      created: true,
+      deleted: false,
+      forced: true,
+      base_ref: nil,
+      compare: "https://github.com/#{@repo}/commit/#{@after[0..12]}",
+      commits: [],
+      repository: {
+        name: repo.split('/').last,
+        full_name: repo,
+        owner: {
+          name: repo.split('/').first
+        }
+      }
+    }
+  end
+
+  def add_commit(options = {})
+    id = if commits.empty? && !options.include?(:id)
+      after
+    else
+      options.fetch(:id) { generate_sha }
+    end
+
+    commit_data = {
+      id: id,
+      distinct: options.fetch(:distinct, true),
+      message: options.fetch(:message, 'Default commit message'),
+      timestamp: options.fetch(:timestamp) { generate_timestamp },
+      url: "https://github.com/#{repo}/commit/#{id}",
+      author: options.fetch(:author, DEFAULT_USER),
+      committer: options.fetch(:committer, DEFAULT_USER),
+      added: options.fetch(:added, []),
+      removed: options.fetch(:removed, []),
+      modified: options.fetch(:modified, [])
+    }
+
+    if commit_data[:id] == after
+      @result[:head_commit] = commit_data
+    end
+
+    commits << commit_data
+  end
+
+  def commits
+    @result[:commits]
+  end
+
+  def head_commit
+    @result[:head_commit]
+  end
+end

data/spec/helpers/integration_setup.rb

@@ -0,0 +1,47 @@
+module IntegrationSetup
+  extend RSpec::SharedContext
+
+  let(:base_config) do
+    {
+      'github' => {
+        'repos' => {
+          'txgh-bot/txgh-test-resources' => {
+            'api_username' => 'txgh-bot',
+            # github will auto-revoke a token if they notice it in one of your commits ;)
+            'api_token' => Base64.decode64('YjViYWY3Nzk5NTdkMzVlMmI0OGZmYjk4YThlY2M1ZDY0NzAwNWRhZA=='),
+            'push_source_to' => 'test-project-88',
+            'branch' => 'master'
+          }
+        }
+      },
+      'transifex' => {
+        'projects' => {
+          'test-project-88' => {
+            'tx_config' => 'file://./config/tx.config',
+            'api_username' => 'txgh.bot',
+            'api_password' => '2aqFGW99fPRKWvXBPjbrxkdiR',
+            'push_translations_to' => 'txgh-bot/txgh-test-resources'
+          }
+        }
+      }
+    }
+  end
+
+  before(:all) do
+    VCR.configure do |config|
+      config.filter_sensitive_data('<GITHUB_TOKEN>') do
+        base_config['github']['repos']['txgh-bot/txgh-test-resources']['api_token']
+      end
+
+      config.filter_sensitive_data('<TRANSIFEX_PASSWORD>') do
+        base_config['transifex']['projects']['test-project-88']['api_password']
+      end
+    end
+  end
+
+  before(:each) do
+    allow(Txgh::Config::KeyManager).to(
+      receive(:base_config).and_return(base_config)
+    )
+  end
+end