txgh 1.0.0

data/spec/resource_downloader_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+require 'helpers/standard_txgh_setup'
+require 'yaml'
+
+include Txgh
+
+describe ResourceDownloader do
+  include StandardTxghSetup
+
+  let(:api_languages) { %w(es de ja) }
+  let(:format) { '.zip' }
+
+  let(:downloader) do
+    ResourceDownloader.new(transifex_project, github_repo, ref)
+  end
+
+  before(:each) do
+    allow(transifex_api).to(
+      receive(:get_languages).with(project_name).and_return(
+        api_languages.map do |language_code|
+          { 'language_code' => language_code }
+        end
+      )
+    )
+
+    allow(transifex_api).to(
+      receive(:download) do |resource, language|
+        translations_for(resource, language)
+      end
+    )
+  end
+
+  def translations_for(resource, language)
+    outdent(%Q{
+      #{language}:
+        string: ! "translation"
+    })
+  end
+
+  context 'with a basic resource' do
+    let(:resource) do
+      tx_config.resource(resource_slug)
+    end
+
+    it 'downloads the resource in all languages' do
+      expect(downloader.each.to_a).to eq(
+        api_languages.map do |language|
+          [
+            "translations/#{language}/sample.yml",
+            translations_for(resource, language)
+          ]
+        end
+      )
+    end
+  end
+
+  context 'with more than one resource' do
+    before(:each) do
+      tx_config.resources << Txgh::TxResource.new(
+        project_name, "#{resource_slug}_second", 'YML',
+        'en', 'en.yml', '', 'translations/<lang>/sample2.yml'
+      )
+
+      allow(Txgh::Config::TxManager).to(
+        receive(:tx_config).and_return(tx_config)
+      )
+    end
+
+    context 'when told to process all branches' do
+      let(:branch) { 'all' }
+
+      it 'includes all resources' do
+        resource = tx_config.resource(resource_slug)
+        actual_results = downloader.each.to_a
+
+        expected_results = api_languages.map do |language|
+          [
+            "translations/#{language}/sample.yml",
+            translations_for(resource, language)
+          ]
+        end
+
+        expected_results += api_languages.map do |language|
+          [
+            "translations/#{language}/sample2.yml",
+            translations_for(resource, language)
+          ]
+        end
+
+        expect(actual_results).to eq(expected_results)
+      end
+    end
+  end
+
+  context 'when told to upload diffs' do
+    let(:diff_point) { 'heads/master' }
+    let(:ref) { 'heads/mybranch' }
+
+    before(:each) do
+      allow(github_api).to receive(:download) do |repo_name, file, branch|
+        source_for(branch)
+      end
+    end
+
+    def source_for(branch)
+      if branch == diff_point
+        diff_point_source_for(branch)
+      else
+        head_source_for(branch)
+      end
+    end
+
+    def head_source_for(branch)
+      # picard unmodified, janeway modified, sisko added, sulu removed
+      outdent(%Q{
+        en:
+          picard: ! "enterprise"
+          janeway: ! "uss voyager"
+          sisko: ! "deep space nine"
+      })
+    end
+
+    def diff_point_source_for(branch)
+      outdent(%Q{
+        en:
+          picard: ! "enterprise"
+          janeway: ! "voyager"
+          sulu: ! "excelsior"
+      })
+    end
+
+    def translations_for(resource, language)
+      branch = resource.respond_to?(:branch) ? resource.branch : nil
+
+      if branch == diff_point
+        diff_point_translations_for(language)
+      else
+        head_translations_for(language)
+      end
+    end
+
+    # picard unmodified, janeway modified, sisko added, sulu removed
+    def head_translations_for(language)
+      outdent(%Q{
+        #{language}:
+          picard: ! "enterprise (head trans)"
+          janeway: ! "uss voyager (head trans)"
+          sisko: ! "deep space nine (head trans)"
+      })
+    end
+
+    def diff_point_translations_for(language)
+      # diff point strings (i.e. strings in master)
+      outdent(%Q{
+        #{language}:
+          picard: ! "enterprise (dp trans)"
+          janeway: ! "voyager (dp trans)"
+          sulu: ! "excelsior (dp trans)"
+      })
+    end
+
+    it 'merges the head and diff point strings together' do
+      # picard unmodified, janeway modified, sisko added, sulu removed
+      expect(downloader.each.to_a).to eq(
+        api_languages.map do |language|
+          [
+            "translations/#{language}/sample.yml",
+            outdent(%Q{
+              #{language}:
+                picard: ! "enterprise (dp trans)"
+                janeway: ! "uss voyager (head trans)"
+                sisko: ! "deep space nine (head trans)"
+            })
+          ]
+        end
+      )
+    end
+
+    it "works even if the resource doesn't exist in transifex" do
+      allow(transifex_api).to(
+        receive(:download) do |resource, language|
+          if resource.respond_to?(:branch)
+            translations_for(resource, language)
+          else
+            raise TransifexNotFoundError
+          end
+        end
+      )
+
+      results = downloader.each.to_a
+      expect(results).to eq(
+        api_languages.map do |language|
+          [
+            "translations/#{language}/sample.yml",
+            outdent(%Q{
+              #{language}:
+                picard: ! "enterprise (dp trans)"
+                janeway: ! "voyager (dp trans)"
+            })
+          ]
+        end
+      )
+    end
+  end
+end

data/spec/resource_updater_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+require 'helpers/standard_txgh_setup'
+
+include Txgh
+
+describe ResourceUpdater do
+  include StandardTxghSetup
+
+  let(:updater) do
+    ResourceUpdater.new(transifex_project, github_repo, logger)
+  end
+
+  let(:branch) { nil }
+  let(:ref) { nil }
+  let(:resource) { tx_config.resource(resource_slug, ref) }
+  let(:commit_sha) { '8765309' }
+
+  let(:modified_files) do
+    [{ 'path' => resource.source_file, 'sha' => 'def456' }]
+  end
+
+  def phrases_for(path)
+    YAML.load("|
+      en:
+        welcome: Hello
+        goodbye: Goodbye
+        new_phrase: I'm new
+    ")
+  end
+
+  before(:each) do
+    tree_sha = 'abc123'
+
+    allow(github_api).to(
+      receive(:get_commit).with(repo_name, commit_sha) do
+        { 'commit' => { 'tree' => { 'sha' => tree_sha } } }
+      end
+    )
+
+    allow(github_api).to(
+      receive(:tree).with(repo_name, tree_sha) do
+        { 'tree' => modified_files }
+      end
+    )
+
+    modified_files.each do |file|
+      translations = phrases_for(file['path'])
+
+      allow(github_api).to(
+        receive(:blob).with(repo_name, file['sha']) do
+          { 'content' => translations, 'encoding' => 'utf-8' }
+        end
+      )
+    end
+  end
+
+  it 'correctly uploads modified files to transifex' do
+    modified_files.each do |file|
+      translations = phrases_for(file['path'])
+
+      expect(transifex_api).to(
+        receive(:create_or_update) do |resource, content|
+          expect(resource.source_file).to eq(file['path'])
+          expect(content).to eq(translations)
+        end
+      )
+    end
+
+    updater.update_resource(resource, commit_sha)
+  end
+
+  context 'when asked to process all branches' do
+    let(:branch) { 'all' }
+    let(:ref) { 'heads/master' }
+
+    it 'uploads by branch name if asked' do
+      allow(transifex_api).to receive(:resource_exists?).and_return(false)
+
+      modified_files.each do |file|
+        translations = phrases_for(file['path'])
+
+        expect(transifex_api).to(
+          receive(:create) do |resource, content, categories|
+            expect(resource.source_file).to eq(file['path'])
+            expect(content).to eq(translations)
+            expect(categories).to include("branch:#{ref}")
+          end
+        )
+      end
+
+      updater.update_resource(resource, commit_sha)
+    end
+
+    it 'adds categories when passed in' do
+      expect(transifex_api).to receive(:resource_exists?).and_return(false)
+
+      modified_files.each do |file|
+        translations = phrases_for(file['path'])
+
+        expect(transifex_api).to(
+          receive(:create) do |resource, content, categories|
+            expect(categories).to include('foo:bar')
+          end
+        )
+      end
+
+      updater.update_resource(resource, commit_sha, { 'foo' => 'bar' })
+    end
+  end
+
+  context 'when asked to upload diffs' do
+    let(:diff_point) { 'heads/diff_point' }
+    let(:resource) do
+      TxResource.new(
+        project_name, resource_slug, 'YAML',
+        'en', 'en.yml', '', 'translation_file'
+      )
+    end
+
+    it 'uploads a diff instead of the whole resource' do
+      expect(github_api).to(
+        receive(:download)
+          .with(repo_name, 'en.yml', diff_point)
+          .and_return(YAML.load("|
+            en:
+              welcome: Hello
+              goodbye: Goodbye
+          "))
+      )
+
+      diff = YAML.load(%Q(|
+        en:
+          new_phrase: ! "I'm new"
+      ))
+
+      expect(updater).to(
+        receive(:upload_by_branch).with(resource, diff, anything)
+      )
+
+      allow(updater).to(
+        receive(:categories_for).and_return({})
+      )
+
+      updater.update_resource(resource, commit_sha)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+
+require 'pry-byebug'
+require 'rake'
+require 'rspec'
+require 'txgh'
+require 'vcr'
+require 'webmock'
+require 'yaml'
+
+module SpecHelpers
+  def outdent(str)
+    # The special YAML pipe operator treats the text that follows as literal,
+    # and includes newlines, tabs, and spaces. It also strips leading tabs and
+    # spaces. This means you can include a fully indented bit of, say, source
+    # code in your source code, and it will give you back a string with all the
+    # indentation preserved (but without any leading indentation).
+    YAML.load("|#{str}")
+  end
+end
+
+RSpec.configure do |config|
+  config.filter_run(focus: true)
+  config.run_all_when_everything_filtered = true
+  config.filter_run_excluding(integration: true) unless ENV['FULL_SPEC']
+  config.include(SpecHelpers)
+end
+
+VCR.configure do |config|
+  config.cassette_library_dir = 'spec/integration/cassettes'
+  config.hook_into :webmock
+end

data/spec/transifex_api_spec.rb

@@ -0,0 +1,345 @@
+require 'spec_helper'
+require 'helpers/standard_txgh_setup'
+
+include Txgh
+
+describe TransifexApi do
+  include StandardTxghSetup
+
+  let(:connection) { double(:connection) }
+  let(:api) { TransifexApi.create_from_connection(connection) }
+  let(:resource) { tx_config.resources.first }
+  let(:response) { double(:response) }
+
+  describe '#create_or_update' do
+    context 'with a preexisting resource' do
+      before(:each) do
+        expect(api).to receive(:resource_exists?).and_return(true)
+      end
+
+      it 'updates the resource with new content' do
+        expect(api).to receive(:update_details).with(resource, categories: [])
+        expect(api).to receive(:update_content).with(resource, 'new_content')
+        expect(api).to receive(:get_resource).and_return({})
+
+        api.create_or_update(resource, 'new_content')
+      end
+
+      it "additively updates the resource's categories" do
+        expect(api).to receive(:update_details) do |rsrc, details|
+          expect(details[:categories].sort).to eq(['branch:foobar', 'name:Jesse James'])
+        end
+
+        expect(api).to receive(:update_content).with(resource, 'new_content')
+        expect(api).to receive(:get_resource).and_return({ 'categories' => ['name:Jesse James'] })
+
+        api.create_or_update(resource, 'new_content', ['branch:foobar'])
+      end
+
+      it 'only submits a unique set of categories' do
+        expect(api).to receive(:update_details).with(resource, categories: ['branch:foobar'])
+        expect(api).to receive(:update_content).with(resource, 'new_content')
+        expect(api).to receive(:get_resource).and_return({ 'categories' => ['branch:foobar'] })
+
+        api.create_or_update(resource, 'new_content', ['branch:foobar'])
+      end
+    end
+
+    context 'with a non-existent resource' do
+      before(:each) do
+        expect(api).to receive(:resource_exists?).and_return(false)
+      end
+
+      it 'makes a request with the correct parameters' do
+        expect(connection).to receive(:post) do |url, payload|
+          expect(url).to(
+            end_with("project/#{project_name}/resources/")
+          )
+
+          expect(payload[:slug]).to eq(resource_slug)
+          expect(payload[:name]).to eq(resource.source_file)
+          expect(payload[:i18n_type]).to eq('YML')
+
+          response
+        end
+
+        allow(response).to receive(:status).and_return(200)
+        allow(response).to receive(:body).and_return("{}")
+        api.create_or_update(resource, 'new_content')
+      end
+    end
+  end
+
+  describe '#create' do
+    it 'makes a request with the correct parameters' do
+      expect(connection).to receive(:post) do |url, payload|
+        expect(url).to(
+          end_with("project/#{project_name}/resources/")
+        )
+
+        expect(payload[:content].io.string).to eq('new_content')
+        expect(payload[:categories]).to eq('abc def')
+        response
+      end
+
+      allow(response).to receive(:status).and_return(200)
+      api.create(resource, 'new_content', ['abc', 'def'])
+    end
+
+    it 'submits de-duped categories' do
+      expect(connection).to receive(:post) do |url, payload|
+        expect(payload[:categories]).to eq('abc')
+        response
+      end
+
+      allow(response).to receive(:status).and_return(200)
+      api.create(resource, 'new_content', ['abc', 'abc'])
+    end
+
+    it 'raises an exception if the api responds with an error code' do
+      allow(connection).to receive(:post).and_return(response)
+      allow(response).to receive(:status).and_return(404)
+      allow(response).to receive(:body).and_return('{}')
+      expect { api.create(resource, 'new_content') }.to raise_error(TransifexApiError)
+    end
+  end
+
+  describe '#delete' do
+    it 'deletes the given resource' do
+      expect(connection).to receive(:delete) do |url|
+        expect(url).to(
+          end_with("project/#{project_name}/resource/#{resource_slug}/")
+        )
+      end
+
+      api.delete(resource)
+    end
+  end
+
+  describe '#update_content' do
+    it 'makes a request with the correct parameters' do
+      expect(connection).to receive(:put) do |url, payload|
+        expect(url).to(
+          end_with("project/#{project_name}/resource/#{resource_slug}/content/")
+        )
+
+        expect(payload[:content].io.string).to eq('new_content')
+        response
+      end
+
+      allow(response).to receive(:status).and_return(200)
+      api.update_content(resource, 'new_content')
+    end
+
+    it 'raises an exception if the api responds with an error code' do
+      allow(connection).to receive(:put).and_return(response)
+      allow(response).to receive(:status).and_return(404)
+      allow(response).to receive(:body).and_return('{}')
+      expect { api.update_content(resource, 'new_content') }.to raise_error(TransifexApiError)
+    end
+  end
+
+  describe '#update_details' do
+    it 'makes a request with the correct parameters' do
+      expect(connection).to receive(:put) do |url, payload|
+        expect(url).to(
+          end_with("project/#{project_name}/resource/#{resource_slug}/")
+        )
+
+        expect(payload[:i18n_type]).to eq('FOO')
+        expect(payload[:categories]).to eq(['abc'])
+        response
+      end
+
+      allow(response).to receive(:status).and_return(200)
+      api.update_details(resource, i18n_type: 'FOO', categories: ['abc'])
+    end
+
+    it 'raises an exception if the api responds with an error code' do
+      allow(connection).to receive(:put).and_return(response)
+      allow(response).to receive(:status).and_return(404)
+      allow(response).to receive(:body).and_return('{}')
+      expect { api.update_details(resource, {}) }.to raise_error(TransifexApiError)
+    end
+  end
+
+  describe '#resource_exists?' do
+    it 'makes a request with the correct parameters' do
+      expect(connection).to receive(:get) do |url|
+        expect(url).to(
+          end_with("project/#{project_name}/resource/#{resource_slug}/")
+        )
+
+        response
+      end
+
+      allow(response).to receive(:status).and_return(200)
+      api.resource_exists?(resource)
+    end
+
+    it 'returns true if the api responds with a 200 status code' do
+      allow(connection).to receive(:get).and_return(response)
+      allow(response).to receive(:status).and_return(200)
+      expect(api.resource_exists?(resource)).to eq(true)
+    end
+
+    it 'returns false if the api does not respond with a 200 status code' do
+      allow(connection).to receive(:get).and_return(response)
+      allow(response).to receive(:status).and_return(404)
+      expect(api.resource_exists?(resource)).to eq(false)
+    end
+  end
+
+  describe '#download' do
+    let(:language) { 'pt-BR' }
+
+    it 'makes a request with the correct parameters' do
+      expect(connection).to receive(:get) do |url|
+        expect(url).to(
+          end_with("project/#{project_name}/resource/#{resource_slug}/translation/#{language}/")
+        )
+
+        response
+      end
+
+      allow(response).to receive(:status).and_return(200)
+      allow(response).to receive(:body).and_return('{}')
+      api.download(resource, language)
+    end
+
+    it 'parses and returns the response content' do
+      allow(connection).to receive(:get).and_return(response)
+      allow(response).to receive(:status).and_return(200)
+      allow(response).to receive(:body).and_return('{"content": "foobar"}')
+      expect(api.download(resource, language)).to eq('foobar')
+    end
+
+    it 'raises an exception if the api responds with an error code' do
+      allow(connection).to receive(:get).and_return(response)
+      allow(response).to receive(:status).and_return(401)
+      allow(response).to receive(:body).and_return('{}')
+      expect { api.download(resource, language) }.to raise_error(TransifexApiError)
+    end
+
+    it 'raises a specific exception if the api responds with a 404 not found' do
+      allow(connection).to receive(:get).and_return(response)
+      allow(response).to receive(:status).and_return(404)
+      allow(response).to receive(:body).and_return('{}')
+      expect { api.download(resource, language) }.to raise_error(
+        TransifexNotFoundError
+      )
+    end
+  end
+
+  describe '#get_resource' do
+    it 'makes a request with the correct parameters' do
+      expect(connection).to receive(:get) do |url, payload|
+        expect(url).to(
+          end_with("project/#{project_name}/resource/#{resource_slug}/")
+        )
+
+        response
+      end
+
+      allow(response).to receive(:status).and_return(200)
+      allow(response).to receive(:body).and_return('{"foo":"bar"}')
+      expect(api.get_resource(*resource.slugs)).to eq({ 'foo' => 'bar' })
+    end
+
+    it 'raises an exception if the api responds with an error code' do
+      allow(connection).to receive(:get).and_return(response)
+      allow(response).to receive(:status).and_return(404)
+      allow(response).to receive(:body).and_return('{}')
+      expect { api.get_resource(*resource.slugs) }.to raise_error(TransifexApiError)
+    end
+  end
+
+  describe '#get_resources' do
+    it 'makes a request with the correct parameters' do
+      expect(connection).to receive(:get) do |url, payload|
+        expect(url).to(
+          end_with("project/#{project_name}/resources/")
+        )
+
+        response
+      end
+
+      allow(response).to receive(:status).and_return(200)
+      allow(response).to receive(:body).and_return('{"foo":"bar"}')
+      expect(api.get_resources(project_name)).to eq({ 'foo' => 'bar' })
+    end
+
+    it 'raises an exception if the api responds with an error code' do
+      allow(connection).to receive(:get).and_return(response)
+      allow(response).to receive(:status).and_return(404)
+      allow(response).to receive(:body).and_return('{}')
+      expect { api.get_resources(project_name) }.to raise_error(TransifexApiError)
+    end
+  end
+
+  describe '#get_languages' do
+    it 'makes a request with the correct parameters' do
+      expect(connection).to receive(:get) do |url, payload|
+        expect(url).to(
+          end_with("project/#{project_name}/languages/")
+        )
+
+        response
+      end
+
+      allow(response).to receive(:status).and_return(200)
+      allow(response).to receive(:body).and_return('[{"language_code":"de"}]')
+      expect(api.get_languages(project_name)).to eq([{ 'language_code' => 'de' }])
+    end
+
+    it 'raises an exception if the api responds with an error code' do
+      allow(connection).to receive(:get).and_return(response)
+      allow(response).to receive(:status).and_return(404)
+      allow(response).to receive(:body).and_return('{}')
+      expect { api.get_languages(project_name) }.to raise_error(TransifexApiError)
+    end
+  end
+
+  describe '#get_project' do
+    it 'makes a request with the correct parameters' do
+      expect(connection).to receive(:get) do |url, payload|
+        expect(url).to(
+          end_with("project/#{project_name}/")
+        )
+
+        response
+      end
+
+      allow(response).to receive(:status).and_return(200)
+      allow(response).to receive(:body).and_return('{"slug":"projectslug"}')
+      expect(api.get_project(project_name)).to eq({ 'slug' => 'projectslug' })
+    end
+
+    it 'raises an exception if the api responds with an error code' do
+      allow(connection).to receive(:get).and_return(response)
+      allow(response).to receive(:status).and_return(404)
+      allow(response).to receive(:body).and_return('{}')
+      expect { api.get_project(project_name) }.to raise_error(TransifexApiError)
+    end
+  end
+
+  describe '#get_formats' do
+    it 'makes a request with the correct parameters' do
+      expect(connection).to receive(:get) do |url, payload|
+        expect(url).to end_with("formats/")
+        response
+      end
+
+      allow(response).to receive(:status).and_return(200)
+      allow(response).to receive(:body).and_return('{}')
+      expect(api.get_formats).to eq({})
+    end
+
+    it 'raises an exception if the api responds with an error code' do
+      allow(connection).to receive(:get).and_return(response)
+      allow(response).to receive(:status).and_return(404)
+      allow(response).to receive(:body).and_return('{}')
+      expect { api.get_formats }.to raise_error(TransifexApiError)
+    end
+  end
+end