rosette-core 1.0.1

data/spec/core/commands/git/repo_snapshot_command_spec.rb

@@ -0,0 +1,72 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core::Commands
+
+describe RepoSnapshotCommand do
+  let(:repo_name) { 'double_commit' }
+
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      config.use_datastore('in-memory')
+    end
+  end
+
+  let(:command) { RepoSnapshotCommand.new(fixture.config) }
+
+  context 'validation' do
+    it 'requires a valid repo name' do
+      command.set_ref('HEAD')
+      expect(command).to_not be_valid
+    end
+
+    it 'requires a valid ref' do
+      command.set_repo_name(repo_name)
+      expect(command).to_not be_valid
+    end
+
+    it 'should be valid if given a valid repo name and ref' do
+      command.set_repo_name(repo_name)
+      command.set_ref('HEAD')
+      expect(command).to be_valid
+    end
+  end
+
+  context '#execute' do
+    let(:commits) do
+      fixture.repo.git("log --pretty=format:'%H'").split("\n")
+    end
+
+    before do
+      command.set_repo_name(repo_name)
+      expect(commits.size).to eq(2)
+    end
+
+    it 'returns a snapshot with one entry per file' do
+      expected_snapshot = {
+        'first_file.txt' => commits.last,
+        'second_file.txt' => commits.first
+      }
+
+      actual_snapshot = command
+        .set_ref(commits.first)
+        .execute
+
+      expect(actual_snapshot).to eq(expected_snapshot)
+    end
+
+    it 'returns a snapshot that only contains the specified paths' do
+      expected_snapshot = {
+        'first_file.txt' => commits.last
+      }
+
+      actual_snapshot = command
+        .set_ref(commits.first)
+        .set_paths(['first_file.txt'])
+        .execute
+
+      expect(actual_snapshot).to eq(expected_snapshot)
+    end
+  end
+end

data/spec/core/commands/git/show_command_spec.rb

@@ -0,0 +1,128 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core::Commands
+
+describe ShowCommand do
+  let(:repo_name) { 'four_commits' }
+
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      config.use_datastore('in-memory')
+      repo_config.add_extractor('test/test') do |extractor_config|
+        extractor_config.set_conditions do |conditions|
+          conditions.match_regex(//)
+        end
+      end
+    end
+  end
+
+  let(:command) { ShowCommand.new(fixture.config) }
+
+  context 'validations' do
+    it 'requires a valid repo name' do
+      command.set_ref('HEAD')
+      expect(command).to_not be_valid
+    end
+
+    it 'requires a ref' do
+      command.set_repo_name(repo_name)
+      expect(command).to_not be_valid
+    end
+
+    it 'should be valid if the repo name and ref are set' do
+      command.set_repo_name(repo_name)
+      command.set_ref('HEAD')
+      expect(command).to be_valid
+    end
+  end
+
+  context '#execute' do
+    before do
+      fixture.each_commit do |fixture_commit|
+        commit(fixture.config, repo_name, fixture_commit.sha)
+      end
+
+      command.set_repo_name(repo_name)
+    end
+
+    context 'when a phrase gets added' do
+      let(:new_key) { 'Yo momma wears army boots' }
+
+      before do
+        fixture.repo.create_file('new_file.txt') do |f|
+          f.write(new_key)
+        end
+
+        fixture.repo.add_all
+        fixture.repo.commit('Adding new_file.txt')
+        commit(fixture.config, repo_name, head_ref(fixture.repo))
+      end
+
+      it 'returns a diff that contains the added phrase' do
+        show_hash = command.set_ref(head_ref(fixture.repo)).execute
+        expect(show_hash[:added].size).to eq(1)
+        expect(show_hash[:added].first.phrase.key).to eq(new_key)
+      end
+    end
+
+    context 'when phrases get removed' do
+      before do
+        fixture.repo.git('rm -f file1.txt')
+        fixture.repo.git('rm -f file2.txt')
+        fixture.add_all
+        fixture.repo.commit('Remove file1.txt and file2.txt')
+
+        commit(fixture.config, repo_name, head_ref(fixture.repo))
+      end
+
+      it 'returns a diff that contains the deleted phrases' do
+        show_hash = command.set_ref(head_ref(fixture.repo)).execute
+        expect(show_hash[:removed].size).to eq(2)
+        expect(show_hash[:removed].map { |entry| entry.phrase.key }.sort).to eq([
+          'bar', 'foo'
+        ])
+      end
+    end
+
+    context "when the parent hasn't been processed yet" do
+      before do
+        command.set_ref(head_ref(fixture.repo))
+        parent_commit_id = fixture.repo.git('rev-parse HEAD~1').strip
+
+        Rosette::DataStores::InMemoryDataStore::CommitLog.entries.reject! do |entry|
+          entry.commit_id == parent_commit_id
+        end
+      end
+
+      it 'raises an error in strict mode' do
+        expect { command.execute }.to raise_error(
+          Rosette::Core::Commands::Errors::UnprocessedCommitError
+        )
+      end
+
+      it 'uses the most recently processed commit in non-strict mode' do
+        show_hash = command.set_strict(false).execute
+        expect(show_hash[:added].map { |entry| entry.phrase.key}.sort).to eq([
+          'goo'
+        ])
+      end
+    end
+  end
+
+  def head_ref(repo)
+    repo.git('rev-parse HEAD').strip
+  end
+
+  def commit(config, repo_name, ref)
+    CommitCommand.new(config)
+      .set_repo_name(repo_name)
+      .set_ref(ref)
+      .execute
+
+    fixture.config.datastore.add_or_update_commit_log(
+      repo_name, ref, nil
+    )
+  end
+end

data/spec/core/commands/git/snapshot_command_spec.rb

@@ -0,0 +1,86 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core::Commands
+
+describe SnapshotCommand do
+  let(:repo_name) { 'double_commit' }
+
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      config.use_datastore('in-memory')
+    end
+  end
+
+  let(:command) { SnapshotCommand.new(fixture.config) }
+
+  context 'validation' do
+    it 'requires a valid repo name' do
+      command.set_ref('HEAD')
+      expect(command).to_not be_valid
+    end
+
+    it 'requires a valid ref' do
+      command.set_repo_name(repo_name)
+      expect(command).to_not be_valid
+    end
+
+    it 'should be valid if given a valid repo name and ref' do
+      command.set_repo_name(repo_name)
+      command.set_ref('HEAD')
+      expect(command).to be_valid
+    end
+  end
+
+  context '#execute' do
+    let(:commits) do
+      fixture.repo.git("log --pretty=format:'%H'").split("\n")
+    end
+
+    before do
+      command.set_repo_name(repo_name)
+      expect(commits.size).to eq(2)
+
+      commits.each do |commit_id|
+        commit(fixture.config, repo_name, commit_id)
+      end
+    end
+
+    it 'returns a list of the phrases from both files' do
+      phrases = command
+        .set_ref(commits.first)
+        .execute
+        .map(&:key)
+
+      expect(phrases.sort).to eq([
+        "I'm a little teapot",
+        'The green albatross flitters in the moonlight',
+        'Chatanooga Choo Choo',
+        "Diamonds are a girl's best friend.",
+        'Cash for the merchandise; cash for the fancy goods.',
+        "I'm in Spañish."
+      ].sort)
+    end
+
+    it 'returns a list of the phrases only at the specified paths' do
+      phrases = command
+        .set_ref(commits.first)
+        .set_paths(['first_file.txt'])
+        .execute
+        .map(&:key)
+
+      expect(phrases.sort).to eq([
+        "I'm a little teapot",
+        'The green albatross flitters in the moonlight'
+      ].sort)
+    end
+  end
+
+  def commit(config, repo_name, ref)
+    CommitCommand.new(config)
+      .set_repo_name(repo_name)
+      .set_ref(ref)
+      .execute
+  end
+end

data/spec/core/commands/git/status_command_spec.rb

@@ -0,0 +1,154 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core::Commands
+
+describe StatusCommand do
+  let(:repo_name) { 'double_commit' }
+  let(:locales) { %w(es de-DE ja-JP) }
+
+  let(:commit_log_locale_model) do
+    Rosette::DataStores::InMemoryDataStore::CommitLogLocale
+  end
+
+  let(:commit_log_model) do
+    Rosette::DataStores::InMemoryDataStore::CommitLog
+  end
+
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      config.use_datastore('in-memory')
+      repo_config.add_locales(locales)
+    end
+  end
+
+  let(:repo_config) { fixture.config.get_repo(repo_name) }
+  let(:command) { StatusCommand.new(fixture.config) }
+
+  context 'validations' do
+    it 'requires a valid repo name' do
+      command.set_ref('HEAD')
+      expect(command).to_not be_valid
+    end
+
+    it 'requires a ref' do
+      command.set_repo_name(repo_name)
+      expect(command).to_not be_valid
+    end
+
+    it 'should be valid if the repo name and ref are set' do
+      command.set_repo_name(repo_name)
+      command.set_ref('HEAD')
+      expect(command).to be_valid
+    end
+  end
+
+  context '#execute' do
+    let(:translated_count) { 6 }
+    let(:phrase_count) { 8 }
+    let(:status) { Rosette::DataStores::PhraseStatus::NOT_SEEN }
+
+    before do
+      commit(fixture.config, repo_name, head_ref(fixture.repo))
+      command.set_ref('HEAD')
+      command.set_repo_name(repo_name)
+
+      repo_config.repo.each_commit do |rev_commit|
+        fixture.config.datastore.add_or_update_commit_log(
+          repo_name,
+          rev_commit.getId.name,
+          nil, status,
+          phrase_count
+        )
+
+        locales.each do |locale|
+          fixture.config.datastore.add_or_update_commit_log_locale(
+            rev_commit.getId.name, locale, translated_count
+          )
+        end
+      end
+    end
+
+    it 'returns the translation status for a commit' do
+      status_result = command.execute
+      expect(status_result[:commit_id]).to eq(head_ref(fixture.repo))
+      expect(status_result[:status]).to eq(Rosette::DataStores::PhraseStatus::NOT_SEEN)
+      expect(status_result[:phrase_count]).to eq(phrase_count * 2)
+
+      locales_result = locales.each_with_object({}) do |locale, ret|
+        ret[locale] = {
+          percent_translated: (translated_count.to_f / phrase_count).round(2),
+          translated_count: translated_count * 2
+        }
+      end
+
+      expect(status_result[:locales]).to eq(locales_result)
+    end
+
+    it 'fills in translation data for missing locales' do
+      index_to_delete = commit_log_locale_model.entries.delete_if do |commit_log|
+        commit_log.locale == locales.first
+      end
+
+      status_result = command.execute
+      untranslated_locale = status_result[:locales][locales.first]
+
+      expect(untranslated_locale).to eq({
+        percent_translated: 0.0,
+        translated_count: 0
+      })
+    end
+
+    context 'with FINALIZED commit logs' do
+      let(:status) { Rosette::DataStores::PhraseStatus::FINALIZED }
+
+      it 'returns a FINALIZED status' do
+        expect(command.execute[:status]).to eq(
+          Rosette::DataStores::PhraseStatus::FINALIZED
+        )
+      end
+    end
+
+    context 'with one NOT_SEEN commit and one PUSHED commit' do
+      before do
+        fixture.config.datastore.add_or_update_commit_log(
+          repo_name,
+          head_ref(fixture.repo),
+          nil, Rosette::DataStores::PhraseStatus::PUSHED,
+          phrase_count
+        )
+      end
+
+      it 'returns a NOT_SEEN status' do
+        expect(command.execute[:status]).to eq(
+          Rosette::DataStores::PhraseStatus::NOT_SEEN
+        )
+      end
+    end
+
+    context 'with an unprocessed commit' do
+      before do
+        commit_log_locale_model.entries.clear
+        commit_log_model.entries.clear
+      end
+
+      it 'returns a NOT_FOUND status' do
+        expect(command.execute[:status]).to eq(
+          Rosette::DataStores::PhraseStatus::NOT_FOUND
+        )
+      end
+    end
+  end
+
+  def head_ref(repo)
+    repo.git('rev-parse HEAD').strip
+  end
+
+  def commit(config, repo_name, ref)
+    CommitCommand.new(config)
+      .set_repo_name(repo_name)
+      .set_ref(ref)
+      .execute
+  end
+end

data/spec/core/commands/queuing/enqueue_commit_command_spec.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core::Commands
+
+describe EnqueueCommitCommand do
+  let(:repo_name) { 'single_commit' }
+
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      config.use_queue('test')
+    end
+  end
+
+  let(:queue) { Rosette::Queuing::TestQueue::Queue }
+  let(:commit_id) { fixture.repo.git('rev-parse HEAD').strip }
+  let(:rosette_config) { fixture.config }
+  let(:command) do
+    EnqueueCommitCommand.new(rosette_config)
+      .set_repo_name(repo_name)
+      .set_commit_id(commit_id)
+  end
+
+  describe '#execute' do
+    it 'enqueues the commit' do
+      expect { command.execute }.to(
+        change { queue.list.size }.from(0).to(1)
+      )
+
+      expect(queue.list.first.commit_id).to eq(commit_id)
+    end
+  end
+end