rosette-core 1.0.1

data/spec/queuing/commits/fetch_stage_spec.rb

@@ -0,0 +1,101 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Queuing::Commits
+include Rosette::DataStores
+
+describe FetchStage do
+  let(:repo_name) { 'single_commit' }
+  let(:commit_id) { fixture.repo.git('rev-parse HEAD').strip }
+
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      config.use_datastore('in-memory')
+    end
+  end
+
+  let(:rosette_config) { fixture.config }
+  let(:repo_config) { rosette_config.get_repo(repo_name) }
+  let(:logger) { NullLogger.new }
+
+  let(:commit_log) do
+    InMemoryDataStore::CommitLog.create(
+      status: PhraseStatus::NOT_SEEN,
+      repo_name: repo_name,
+      commit_id: commit_id,
+      phrase_count: 0,
+      commit_datetime: nil,
+      branch_name: nil
+    )
+  end
+
+  let(:stage) do
+    FetchStage.new(rosette_config, repo_config, logger, commit_log)
+  end
+
+  let(:git) { double(:git) }
+  let(:git_message_chain) { [:fetch, :setRemote, :setRemoveDeletedRefs] }
+
+  before(:each) do
+    stage.instance_variable_set(:'@git', git)
+
+    allow(git).to(
+      receive_message_chain(git_message_chain).and_return(git)
+    )
+  end
+
+  describe '#execute!' do
+    it 'runs a git fetch on the repo' do
+      expect(git).to receive(:call)
+      stage.execute!
+    end
+
+    context 'with a mocked fetch operation' do
+      before(:each) do
+        allow(git).to receive(:call)
+      end
+
+      it 'updates the commit log status' do
+        stage.execute!
+        expect(commit_log.status).to eq(PhraseStatus::FETCHED)
+      end
+
+      it 'sets branch_name to the master branch if the commit exists in master' do
+        remote_repo = TmpRepo.new
+
+        # git doesn't allow you to push to the currently checked out branch, so
+        # create a new branch to avoid an error
+        remote_repo.git('checkout -b new_branch')
+        fixture.repo.git("remote add origin #{remote_repo.working_dir}")
+        fixture.repo.git('push origin HEAD')
+
+        stage.execute!
+        entry = InMemoryDataStore::CommitLog.entries.first
+        expect(entry.branch_name).to eq('refs/remotes/origin/master')
+
+        remote_repo.unlink
+      end
+
+      it 'sets branch_name to the first remote ref when creating a new commit log' do
+        fixture.repo.git('checkout -b my_branch')
+        fixture.repo.create_file('test.txt') do |writer|
+          writer.write('test test test')
+        end
+
+        fixture.repo.add_all
+        fixture.repo.commit('Commit message')
+
+        remote_repo = TmpRepo.new
+        fixture.repo.git("remote add origin #{remote_repo.working_dir}")
+        fixture.repo.git('push origin HEAD')
+
+        stage.execute!
+        entry = InMemoryDataStore::CommitLog.entries.first
+        expect(entry.branch_name).to eq('refs/remotes/origin/my_branch')
+
+        remote_repo.unlink
+      end
+    end
+  end
+end

data/spec/queuing/commits/finalize_stage_spec.rb

@@ -0,0 +1,88 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Queuing::Commits
+include Rosette::DataStores
+include Rosette::Core
+
+describe FinalizeStage do
+  let(:repo_name) { 'single_commit' }
+  let(:commit_id) { fixture.repo.git('rev-parse HEAD').strip }
+
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      config.use_datastore('in-memory')
+      repo_config.use_tms('test')
+      repo_config.add_locales(%w(pt-BR ja-JP))
+    end
+  end
+
+  let(:rosette_config) { fixture.config }
+  let(:repo_config) { rosette_config.get_repo(repo_name) }
+  let(:logger) { NullLogger.new }
+
+  let(:commit_log) do
+    InMemoryDataStore::CommitLog.create(
+      status: PhraseStatus::PUSHED,
+      repo_name: repo_name,
+      commit_id: commit_id,
+      phrase_count: 10,
+      commit_datetime: nil,
+      branch_name: 'refs/heads/master'
+    )
+  end
+
+  let(:stage) do
+    FinalizeStage.new(rosette_config, repo_config, logger, commit_log)
+  end
+
+  describe '#execute!' do
+    before(:each) do
+      allow(repo_config.tms).to receive(:status).and_return(
+        TranslationStatus.new(commit_log.phrase_count).tap do |status|
+          repo_config.locales.each do |locale|
+            status.add_locale_count(locale.code, locale_count)
+          end
+        end
+      )
+    end
+
+    context 'with a not fully translated status' do
+      let(:locale_count) { commit_log.phrase_count - 1 }
+
+      it "creates commit log locale entries and doesn't update the status" do
+        expect(repo_config.tms).to_not receive(:finalize)
+        stage.execute!
+        expect(commit_log.status).to eq(PhraseStatus::PUSHED)
+        entries = InMemoryDataStore::CommitLogLocale.map(&:translated_count)
+        entries.each { |e| expect(e).to eq(commit_log.phrase_count - 1) }
+      end
+    end
+
+    context 'with a fully translated status' do
+      let(:locale_count) { commit_log.phrase_count }
+
+      it 'calls finalize on the tms, updates the status, and creates entries' do
+        expect(repo_config.tms).to receive(:finalize)
+        stage.execute!
+        expect(commit_log.status).to eq(PhraseStatus::FINALIZED)
+        entries = InMemoryDataStore::CommitLogLocale.map(&:translated_count)
+        entries.each { |e| expect(e).to eq(commit_log.phrase_count) }
+      end
+    end
+  end
+
+  describe '#to_job' do
+    it 'adds a delay to the job if the status is still PUSHED' do
+      job = stage.to_job
+      expect(job.delay).to be > 0
+    end
+
+    it 'does not add a delay if the job is FINALIZED' do
+      stage.commit_log.status = PhraseStatus::FINALIZED
+      job = stage.to_job
+      expect(job.delay).to eq(0)
+    end
+  end
+end

data/spec/queuing/commits/push_stage_spec.rb

@@ -0,0 +1,145 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Queuing::Commits
+include Rosette::DataStores
+
+describe PushStage do
+  let(:repo_name) { 'single_commit' }
+
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      repo_config.use_tms('test')
+      config.use_datastore('in-memory')
+      config.use_queue('test') do |queue_config|
+        queue_config.enable_queue('commits')
+      end
+    end
+  end
+
+  let(:rosette_config) { fixture.config }
+  let(:repo_config) { rosette_config.get_repo(repo_name) }
+  let(:logger) { NullLogger.new }
+
+  describe '#execute!' do
+    context 'with a single commit' do
+      let(:commit_log) do
+        InMemoryDataStore::CommitLog.create(
+          status: PhraseStatus::FETCHED,
+          repo_name: repo_name,
+          commit_id: commit_id,
+          phrase_count: 0,
+          commit_datetime: nil,
+          branch_name: 'refs/heads/master'
+        )
+      end
+
+      let(:stage) do
+        PushStage.new(rosette_config, repo_config, logger, commit_log)
+      end
+
+      let(:commit_id) { fixture.repo.git('rev-parse HEAD').strip }
+
+      before(:each) do
+        args = [rosette_config, repo_config, logger, commit_log]
+        ExtractStage.new(*args).execute!
+      end
+
+      it 'updates the status to FINALIZED when no phrases are found' do
+        expect(stage).to receive(:phrases).and_return([])
+        stage.execute!
+        expect(commit_log.status).to eq(PhraseStatus::FINALIZED)
+      end
+
+      it 'stores the phrases in the repository' do
+        stage.execute!
+        phrases = repo_config.tms.stored_phrases[commit_id].map(&:key)
+        expect(phrases).to include('The green albatross flitters in the moonlight')
+        expect(phrases).to include('Chatanooga Choo Choo')
+        expect(phrases).to include(' test string 1')
+      end
+
+      it 'updates the commit log status' do
+        stage.execute!
+        expect(commit_log.status).to eq(PhraseStatus::PUSHED)
+      end
+
+      it "updates the status to MISSING if one of the objects doesn't exist" do
+        fixture.repo.git('reset --hard HEAD')
+        fixture.repo.create_file('testfile.txt') { |f| f.write('foo') }
+        fixture.repo.add_all
+        fixture.repo.commit('Test commit')
+
+        commit_log.commit_id = fixture.repo.git('rev-parse HEAD').strip
+
+        fixture.repo.git('reset --hard HEAD~1')
+        fixture.repo.git('reflog expire --expire=now --all')
+        fixture.repo.git('fsck --unreachable')
+        fixture.repo.git('prune -v')
+
+        stage.execute!
+        expect(commit_log.status).to eq(PhraseStatus::MISSING)
+      end
+    end
+  end
+
+  context 'with a git branch' do
+    before(:each) do
+      fixture.repo.create_branch('my_branch')
+
+      fixture.repo.create_file('testfile.txt') { |f| f.write('first') }
+      fixture.repo.add_all
+      fixture.repo.commit('Test commit')
+
+      fixture.repo.create_file('anothertestfile.txt') { |f| f.write('second') }
+      fixture.repo.add_all
+      fixture.repo.commit('Another test commit')
+
+      fixture.repo.each_commit_id do |commit_id|
+        commit_log = InMemoryDataStore::CommitLog.create(
+          status: PhraseStatus::FETCHED,
+          repo_name: repo_name,
+          commit_id: commit_id,
+          phrase_count: 0,
+          commit_datetime: nil,
+          branch_name: 'refs/heads/my_branch'
+        )
+
+        args = [rosette_config, repo_config, logger, commit_log]
+        ExtractStage.new(*args).execute!
+      end
+    end
+
+    context 'with phrase storage granularity set to BRANCH' do
+      before(:each) do
+        queue = rosette_config.queue.configurator.get_queue_config('commits')
+        queue.set_phrase_storage_granularity(PhraseStorageGranularity::BRANCH)
+      end
+
+      let(:commit_log) do
+        InMemoryDataStore::CommitLog.entries.first
+      end
+
+      let(:stage) do
+        PushStage.new(rosette_config, repo_config, logger, commit_log)
+      end
+
+      describe '#execute' do
+        it 'pushes all the phrases in the branch' do
+          stage.execute!
+          phrases = repo_config.tms.stored_phrases[commit_log.commit_id]
+          keys = phrases.map(&:key)
+          expect(keys).to eq(%w(second first))
+        end
+
+        it 'pushes by commit if the branch name is null' do
+          commit_log.branch_name = nil
+          stage.execute!
+          phrases = repo_config.tms.stored_phrases[commit_log.commit_id]
+          expect(phrases.map(&:key)).to eq(%w(second))
+        end
+      end
+    end
+  end
+end

data/spec/queuing/commits/stage_spec.rb

@@ -0,0 +1,80 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Queuing::Commits
+include Rosette::DataStores
+
+describe Stage do
+  let(:stage_class) { Class.new(Stage) }
+  let(:repo_name) { 'single_commit' }
+  let(:commit_id) { '123abc' }
+
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      config.use_datastore('in-memory')
+    end
+  end
+
+  let(:rosette_config) { fixture.config }
+  let(:repo_config) { rosette_config.get_repo(repo_name) }
+  let(:logger) { NullLogger.new }
+
+  let(:pushed_commit_log) do
+    InMemoryDataStore::CommitLog.create(
+      status: PhraseStatus::PUSHED, repo_name: repo_name, commit_id: commit_id
+    )
+  end
+
+  let(:extracted_commit_log) do
+    InMemoryDataStore::CommitLog.create(
+      status: PhraseStatus::EXTRACTED, repo_name: repo_name, commit_id: commit_id
+    )
+  end
+
+  before(:each) do
+    stage_class.accepts(PhraseStatus::EXTRACTED)
+  end
+
+  describe '.accepts?' do
+    it 'returns true if the stage accepts the given commit log' do
+      expect(stage_class.accepts?(extracted_commit_log)).to be_truthy
+    end
+
+    it 'returns false if the stage does not accept the given commit log' do
+      expect(stage_class.accepts?(pushed_commit_log)).to be_falsy
+    end
+  end
+
+  describe '.for_commit_log' do
+    it "returns nil if the commit log isn't accepted" do
+      result = stage_class.for_commit_log(
+        pushed_commit_log, rosette_config, logger
+      )
+
+      expect(result).to be_nil
+    end
+
+    it 'wraps the commit log in a stage instance' do
+      result = stage_class.for_commit_log(
+        extracted_commit_log, rosette_config, logger
+      )
+
+      expect(result).to be_a(stage_class)
+      expect(result.rosette_config).to eq(rosette_config)
+      expect(result.repo_config).to_not be_nil
+      expect(result.logger).to eq(logger)
+      expect(result.commit_log).to eq(extracted_commit_log)
+    end
+  end
+
+  describe '#to_job' do
+    let(:stage) do
+      stage_class.new(rosette_config, repo_config, logger, extracted_commit_log)
+    end
+
+    it 'converts the stage to a job' do
+      expect(stage.to_job).to be_a(CommitJob)
+    end
+  end
+end

data/spec/queuing/job_spec.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Queuing
+
+describe Job do
+  let(:job_class) { Class.new(Job) }
+
+  describe '.queue_name' do
+    it 'returns the default queue name' do
+      expect(job_class.queue_name).to eq('default')
+    end
+
+    it 'returns a custom queue name' do
+      job_class.set_queue_name('foobar')
+      expect(job_class.queue_name).to eq('foobar')
+    end
+  end
+
+  describe '#set_delay' do
+    let(:job) { job_class.new }
+
+    it 'checks the delay is set to zero by default' do
+      expect(job.delay).to eq(0)
+    end
+
+    it 'sets the delay' do
+      job.set_delay(10)
+      expect(job.delay).to eq(10)
+    end
+  end
+end