txgh 1.0.0

data/spec/github_repo_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+include Txgh
+
+describe GithubRepo do
+  let(:repo_name) { 'my_org/my_repo' }
+  let(:branch) { 'master' }
+  let(:tag) { 'tags/foo' }
+  let(:api) { :api }
+  let(:repo) { GithubRepo.new(config, api) }
+  let(:diff_point) { nil }
+  let(:config) do
+    {
+      'name' => repo_name, 'branch' => branch, 'tag' => tag,
+      'diff_point' => diff_point
+    }
+  end
+
+  describe '#name' do
+    it 'retrieves the repo name from the config' do
+      expect(repo.name).to eq(repo_name)
+    end
+  end
+
+  describe '#branch' do
+    it 'retrieves the branch name from the config' do
+      expect(repo.branch).to eq(branch)
+    end
+  end
+
+  describe '#tag' do
+    it 'retrieves the tag name from the config' do
+      expect(repo.tag).to eq(tag)
+    end
+  end
+
+  describe '#process_all_branches?' do
+    it 'returns false if only one branch should be processed' do
+      expect(repo.process_all_branches?).to eq(false)
+    end
+
+    context 'with all branches indicated' do
+      let(:branch) { 'all' }
+
+      it 'returns true if all branches should be processed' do
+        expect(repo.process_all_branches?).to eq(true)
+      end
+    end
+  end
+
+  describe '#process_all_tags?' do
+    it 'returns false if only one tag should be processed' do
+      expect(repo.process_all_tags?).to eq(false)
+    end
+
+    context 'with all tags indicated' do
+      let(:tag) { 'all' }
+
+      it 'returns true if all tags should be processed' do
+        expect(repo.process_all_tags?).to eq(true)
+      end
+    end
+  end
+
+  describe '#should_process_ref?' do
+    context 'with all branches indicated' do
+      let(:branch) { 'all' }
+
+      it 'returns true if all branches should be processed' do
+        expect(repo.should_process_ref?('heads/foo')).to eq(true)
+      end
+    end
+
+    context 'with all tags indicated' do
+      let(:tag) { 'all' }
+
+      it 'returns true if all tags should be processed' do
+        expect(repo.should_process_ref?('tags/foo')).to eq(true)
+      end
+    end
+
+    it 'returns true if the given branch matches the configured one' do
+      expect(repo.should_process_ref?('heads/master')).to eq(true)
+    end
+
+    it "returns false if the given branch doesn't match the configured one" do
+      expect(repo.should_process_ref?('heads/foo')).to eq(false)
+    end
+
+    it 'returns true if the branch contains the special L10N text' do
+      expect(repo.should_process_ref?('heads/L10N_foo')).to eq(true)
+    end
+
+    it 'returns true if the given tag matches the configured one' do
+      expect(repo.should_process_ref?('tags/foo')).to eq(true)
+    end
+
+    it "returns false if the given tag doesn't match the configured one" do
+      expect(repo.should_process_ref?('heads/foobar')).to eq(false)
+    end
+  end
+
+  describe '#github_config_branch' do
+    context 'with all branches indicated' do
+      let(:branch) { 'all' }
+
+      it "doesn't modify the passed branch, i.e. returns 'all'" do
+        expect(repo.github_config_branch).to eq('all')
+      end
+    end
+
+    context 'with a nil branch' do
+      let(:branch) { nil }
+
+      it 'chooses master by default' do
+        expect(repo.github_config_branch).to eq('heads/master')
+      end
+    end
+
+    context 'with a configured branch' do
+      let(:branch) { 'foobar' }
+
+      it 'correctly prefixes the branch' do
+        expect(repo.github_config_branch).to eq('heads/foobar')
+      end
+    end
+  end
+
+  describe '#github_config_tag' do
+    context 'with all tags indicated' do
+      let(:tag) { 'all' }
+
+      it "doesn't modify the passed tag, i.e. returns 'all'" do
+        expect(repo.github_config_tag).to eq('all')
+      end
+    end
+
+    context 'with a nil tag' do
+      let(:tag) { nil }
+
+      it 'returns nil' do
+        expect(repo.github_config_tag).to be_nil
+      end
+    end
+
+    context 'with a configured tag' do
+      let(:tag) { 'tags/foobar' }
+
+      it 'leaves the prefix intact' do
+        expect(repo.github_config_tag).to eq('tags/foobar')
+      end
+    end
+  end
+
+  describe '#upload_diffs?' do
+    it 'returns false by default' do
+      expect(repo.upload_diffs?).to eq(false)
+    end
+
+    context 'with a configured diff point' do
+      let(:diff_point) { 'heads/master' }
+
+      it 'returns true when a diff point is configured' do
+        expect(repo.upload_diffs?).to eq(true)
+      end
+    end
+  end
+
+  describe '#diff_point' do
+    context 'with a configured diff point' do
+      let(:diff_point) { 'heads/master' }
+
+      it 'returns the provided diff point' do
+        expect(repo.diff_point).to eq(diff_point)
+      end
+    end
+  end
+end

data/spec/github_request_auth_spec.rb

@@ -0,0 +1,39 @@
+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

data/spec/handlers/download_handler_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'helpers/standard_txgh_setup'
+require 'yaml'
+
+include Txgh::Handlers
+
+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
+  end
+end

data/spec/handlers/github/delete_handler_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'helpers/github_payload_builder'
+require 'helpers/standard_txgh_setup'
+
+include Txgh
+include Txgh::Handlers::Github
+
+describe DeleteHandler do
+  include StandardTxghSetup
+
+  let(:handler) do
+    DeleteHandler.new(
+      project: transifex_project,
+      repo: github_repo,
+      payload: payload.to_h,
+      logger: logger
+    )
+  end
+
+  # process all branches
+  let(:branch) { 'all' }
+
+  let(:payload) do
+    GithubPayloadBuilder.delete_payload(repo_name, ref)
+  end
+
+  let(:resource) { tx_config.resources.first }
+
+  let(:resource_api_response) do
+    [resource.to_api_h.merge('categories' => ["branch:#{ref}"])]
+  end
+
+  let(:resource_slug_with_branch) do
+    "#{resource_slug}-#{Utils.slugify(ref)}"
+  end
+
+  it 'deletes the correct resource from transifex' do
+    expect(transifex_api).to(
+      receive(:get_resources).and_return(resource_api_response)
+    )
+
+    expect(transifex_api).to receive(:delete) do |tx_resource|
+      expect(tx_resource.project_slug).to eq(project_name)
+      expect(tx_resource.resource_slug).to eq(resource_slug_with_branch)
+    end
+
+    response = handler.execute
+    expect(response.status).to eq(200)
+    expect(response.body).to eq(true)
+  end
+
+  it "does not delete resources that don't have a matching branch" do
+    handler.payload['ref'] = 'heads/im_fake'
+    expect(transifex_api).to(
+      receive(:get_resources).and_return(resource_api_response)
+    )
+
+    expect(transifex_api).to_not receive(:delete)
+    response = handler.execute
+    expect(response.status).to eq(200)
+    expect(response.body).to eq(true)
+  end
+
+  it 'does not delete resources if auto resource deletions are disabled' do
+    project_config['auto_delete_resources'] = 'false'
+    expect(transifex_api).to_not receive(:delete)
+    response = handler.execute
+    expect(response.status).to eq(200)
+    expect(response.body).to eq(true)
+  end
+end

data/spec/handlers/github/push_handler_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'helpers/github_payload_builder'
+require 'helpers/standard_txgh_setup'
+
+include Txgh
+include Txgh::Handlers::Github
+
+describe PushHandler do
+  include StandardTxghSetup
+
+  let(:handler) do
+    PushHandler.new(
+      project: transifex_project,
+      repo: github_repo,
+      payload: payload.to_h,
+      logger: logger
+    )
+  end
+
+  let(:payload) do
+    GithubPayloadBuilder.push_payload(repo_name, ref)
+  end
+
+  let(:modified_files) do
+    file_sha = 'def456'
+    tx_config.resources.map do |resource|
+      { 'path' => resource.source_file, 'sha' => file_sha.next! }
+    end
+  end
+
+  let(:updater) { double(:updater) }
+
+  before(:each) do
+    payload.add_commit(
+      modified: modified_files.map { |f| f['path'] }
+    )
+
+    expect(ResourceUpdater).to receive(:new).and_return(updater)
+  end
+
+  it 'correctly uploads modified resources to transifex' do
+    tx_config.resources.each do |resource|
+      expect(updater).to(
+        receive(:update_resource) do |resource, sha, categories|
+          expect(resource.project_slug).to eq(project_name)
+          expect(resource.resource_slug).to eq(resource_slug)
+          expect(sha).to eq(payload.head_commit[:id])
+          expect(categories).to eq('author' => 'Test User')
+        end
+      )
+    end
+
+    response = handler.execute
+    expect(response.status).to eq(200)
+    expect(response.body).to eq(true)
+  end
+
+  context 'with an L10N branch' do
+    let(:ref) { 'tags/L10N_my_branch' }
+
+    it 'creates an L10N tag' do
+      expect(updater).to receive(:update_resource)
+
+      # this is what we actually care about in this test
+      expect(github_api).to(
+        receive(:create_ref).with(
+          repo_name, 'heads/L10N', payload.head_commit[:id]
+        )
+      )
+
+      response = handler.execute
+      expect(response.status).to eq(200)
+      expect(response.body).to eq(true)
+    end
+  end
+end