txgh 5.3.4 → 5.4.0

data/spec/handlers/download_handler_spec.rb

@@ -1,91 +0,0 @@
-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
-
-    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/handlers/github/delete_handler_spec.rb

@@ -1,71 +0,0 @@
-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_resource) 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/ping_handler_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-include Txgh
-include Txgh::Handlers::Github
-
-describe PingHandler do
-  let(:handler) do
-    PingHandler.new
-  end
-
-  it 'responds with a 200 success' do
-    response = handler.execute
-    expect(response.status).to eq(200)
-    expect(response.body).to eq({})
-  end
-end

data/spec/handlers/github/push_handler_spec.rb

@@ -1,106 +0,0 @@
-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'] }
-    )
-
-    allow(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
-      )
-
-      expect(github_api).to(
-        receive(:get_ref).with(repo_name, ref).and_return(
-          object: { sha: payload.head_commit[:id] }
-        )
-      )
-    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]
-        )
-      )
-
-      expect(github_api).to(
-        receive(:get_ref).with(repo_name, ref).and_return(
-          object: { sha: payload.head_commit[:id] }
-        )
-      )
-
-      response = handler.execute
-      expect(response.status).to eq(200)
-      expect(response.body).to eq(true)
-    end
-  end
-
-  context 'with a deleted branch' do
-    let(:before) { nil }
-    let(:after) { '0' * 40 }
-
-    let(:payload) do
-      GithubPayloadBuilder.push_payload(repo_name, ref, before, after)
-    end
-
-    it "doesn't upload anything" do
-      expect(updater).to_not receive(:update_resource)
-      expect(github_api).to_not receive(:create_ref)
-
-      response = handler.execute
-      expect(response.status).to eq(200)
-      expect(response.body).to eq(true)
-    end
-  end
-end

data/spec/handlers/tgz_stream_response_spec.rb

@@ -1,59 +0,0 @@
-require 'rubygems/package'
-require 'spec_helper'
-require 'stringio'
-require 'zlib'
-
-include Txgh::Handlers
-
-describe TgzStreamResponse do
-  def read_tgz_from(io)
-    contents = {}
-
-    Zlib::GzipReader.wrap(io) do |gz|
-      tar = Gem::Package::TarReader.new(gz)
-      tar.each do |entry|
-        contents[entry.full_name] = entry.read
-      end
-    end
-
-    contents
-  end
-
-  let(:attachment) { 'abc123' }
-
-  let(:enum) do
-    {
-      'first_file.yml' => "first\nfile\ncontents\n",
-      'second_file.yml' => "wowowow\nanother file!\n"
-    }
-  end
-
-  let(:response) do
-    TgzStreamResponse.new(attachment, enum)
-  end
-
-  describe '#write_to' do
-    it 'writes a gzipped tar file with the correct entries to the stream' do
-      io = StringIO.new('', 'wb')
-      response.write_to(io)
-      io = io.reopen(io.string, 'rb')
-      contents = read_tgz_from(io)
-      expect(contents).to eq(enum)
-    end
-  end
-
-  describe '#headers' do
-    it 'includes the correct content type and disposition headers' do
-      expect(response.headers).to eq({
-        'Content-Disposition' => "attachment; filename=\"#{attachment}.tgz\"",
-        'Content-Type' => 'application/x-gtar'
-      })
-    end
-  end
-
-  describe '#streaming?' do
-    it 'returns true' do
-      expect(response).to be_streaming
-    end
-  end
-end

data/spec/handlers/transifex/hook_handler_spec.rb

@@ -1,136 +0,0 @@
-require 'spec_helper'
-require 'helpers/nil_logger'
-require 'helpers/standard_txgh_setup'
-
-include Txgh
-include Txgh::Handlers::Transifex
-
-describe HookHandler do
-  include StandardTxghSetup
-
-  let(:requested_resource_slug) do
-    resource_slug
-  end
-
-  let(:handler) do
-    HookHandler.new(
-      project: transifex_project,
-      repo: github_repo,
-      resource_slug: requested_resource_slug,
-      language: language,
-      logger: logger
-    )
-  end
-
-  let(:downloader) do
-    instance_double(ResourceDownloader)
-  end
-
-  let(:file_name) do
-    "translations/#{language}/sample.yml"
-  end
-
-  before(:each) do
-    allow(ResourceDownloader).to receive(:new).and_return(downloader)
-    allow(downloader).to(receive(:first)).and_return([
-      "translations/#{language}/sample.yml", translations
-    ])
-
-    allow(github_api).to receive(:get_ref).and_return(
-      object: { sha: '123abcshashasha' }
-    )
-  end
-
-  it 'downloads translations and pushes them to the correct branch (head)' do
-    expect(github_api).to(
-      receive(:update_contents).with(
-        repo_name, "heads/#{branch}",
-        { "translations/#{language}/sample.yml" => translations },
-        "Updating #{language} translations in #{file_name}"
-      )
-    )
-
-    response = handler.execute
-    expect(response.status).to eq(200)
-    expect(response.body).to eq(true)
-  end
-
-  it "responds with an error if the config can't be found" do
-    expect(handler).to receive(:tx_config).and_return(nil)
-    response = handler.execute
-    expect(response.status).to eq(404)
-    expect(response.body).to eq([
-      { error: "Could not find configuration for branch 'heads/#{branch}'" }
-    ])
-  end
-
-  context 'with a non-existent resource' do
-    let(:requested_resource_slug) { 'foobarbazboo' }
-
-    it "responds with an error if the resource can't be found" do
-      response = handler.execute
-      expect(response.status).to eq(404)
-      expect(response.body).to eq(
-        [{ error: "Could not find resource '#{requested_resource_slug}' in config" }]
-      )
-    end
-  end
-
-  context 'when asked to process all branches' do
-    let(:branch) { 'all' }
-    let(:ref) { 'heads/my_branch' }
-
-    let(:requested_resource_slug) do
-      'my_resource-heads_my_branch'
-    end
-
-    it 'pushes to the individual branch' do
-      expect(transifex_api).to receive(:get_resource) do
-        { 'categories' => ["branch:#{ref}"] }
-      end
-
-      expect(github_api).to(
-        receive(:update_contents).with(
-          repo_name, ref,
-          { "translations/#{language}/sample.yml" => translations },
-          "Updating #{language} translations in #{file_name}"
-        )
-      )
-
-      response = handler.execute
-      expect(response.status).to eq(200)
-      expect(response.body).to eq(true)
-    end
-  end
-
-  context 'with a tag instead of a branch' do
-    let(:branch) { 'tags/my_tag' }
-
-    it 'downloads translations and pushes them to the tag' do
-      expect(github_api).to(
-        receive(:update_contents).with(
-          repo_name, "tags/my_tag",
-          { "translations/#{language}/sample.yml" => translations },
-          "Updating #{language} translations in #{file_name}"
-        )
-      )
-
-      response = handler.execute
-      expect(response.status).to eq(200)
-      expect(response.body).to eq(true)
-    end
-  end
-
-  context 'with an unsupported language' do
-    let(:language) { 'pt' }
-    let(:supported_languages) { ['ja'] }
-
-    it "doesn't make a commit" do
-      expect(github_api).to_not receive(:update_contents)
-
-      response = handler.execute
-      expect(response.status).to eq(304)
-      expect(response.body).to eq(true)
-    end
-  end
-end

data/spec/handlers/zip_stream_response_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-require 'tempfile'
-
-include Txgh::Handlers
-
-describe ZipStreamResponse do
-  def read_zip_from(file)
-    contents = {}
-
-    Zip::File.open(file) do |zipfile|
-      zipfile.each do |entry|
-        contents[entry.name] = entry.get_input_stream.read
-      end
-    end
-
-    contents
-  end
-
-  let(:attachment) { 'abc123' }
-
-  let(:enum) do
-    {
-      'first_file.yml' => "first\nfile\ncontents\n",
-      'second_file.yml' => "wowowow\nanother file!\n"
-    }
-  end
-
-  let(:response) do
-    ZipStreamResponse.new(attachment, enum)
-  end
-
-  describe '#write_to' do
-    it 'writes a zip file with the correct entries to the stream' do
-      # this does NOT WORK with a StringIO - zip contents MUST be written to a file
-      io = Tempfile.new('testzip')
-      response.write_to(io)
-      contents = read_zip_from(io.path)
-      expect(contents).to eq(enum)
-      io.close
-      io.unlink
-    end
-  end
-
-  describe '#headers' do
-    it 'includes the correct content type and disposition headers' do
-      expect(response.headers).to eq({
-        'Content-Disposition' => "attachment; filename=\"#{attachment}.zip\"",
-        'Content-Type' => 'application/zip'
-      })
-    end
-  end
-
-  describe '#streaming?' do
-    it 'returns true' do
-      expect(response).to be_streaming
-    end
-  end
-end

data/spec/helpers/github_payload_builder.rb

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