rosette-core 1.0.1

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

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core::Commands
+include Rosette::DataStores
+
+describe RequeueCommitCommand do
+  let(:repo_name) { 'single_commit' }
+
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      config.use_queue('test')
+      config.use_datastore('in-memory')
+    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
+    RequeueCommitCommand.new(rosette_config)
+      .set_repo_name(repo_name)
+      .set_commit_id(commit_id)
+  end
+
+  describe '#execute' do
+    let!(:commit_log) do
+      InMemoryDataStore::CommitLog.create(
+        repo_name: repo_name, commit_id: commit_id,
+        status: PhraseStatus::EXTRACTED, phrase_count: 0,
+        branch_name: 'refs/remotes/origin/master',
+        commit_datetime: Time.now
+      )
+    end
+
+    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)
+      expect(commit_log.status).to eq(PhraseStatus::NOT_FOUND)
+    end
+  end
+end

data/spec/core/commands/translations/export_command_spec.rb

@@ -0,0 +1,113 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core::Commands
+
+describe ExportCommand do
+  let(:repo_name) { 'single_commit' }
+  let(:locales) { %w(es de-DE ja-JP) }
+  let(:phrase_model) { Rosette::DataStores::InMemoryDataStore::Phrase }
+
+  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(locales)
+      repo_config.add_serializer('test', format: 'test/test')
+    end
+  end
+
+  let(:commit_id) { fixture.repo.git('rev-parse HEAD').strip }
+  let(:rosette_config) { fixture.config }
+  let(:repo_config) { rosette_config.get_repo(repo_name) }
+  let(:command) { ExportCommand.new(rosette_config) }
+
+  before do
+    CommitCommand.new(rosette_config)
+      .set_repo_name(repo_name)
+      .set_ref(commit_id)
+      .execute
+
+    command.set_repo_name(repo_name)
+      .set_ref(commit_id)
+      .set_locale(locales.first)
+      .set_serializer('test/test')
+
+    phrase_model.entries.each do |phrase|
+      repo_config.tms.store_phrase(phrase, commit_id)
+      repo_config.tms.auto_translate(command.send(:locale_obj), phrase)
+    end
+  end
+
+  it 'exports translations from the given commit' do
+    result = command.execute
+
+    test_pairs = [
+      "I'm a little teapot = i'may aay ittlelay eapottay",
+      "Diamonds are a girl's best friend. = iamondsday areay aay irl'sgay estbay iendfray.",
+      "string2 =  esttay ingstray 2"
+    ]
+
+    test_pairs.each do |test_pair|
+      expect(result[:payload]).to include(test_pair)
+    end
+  end
+
+  it 'includes basic information about the payload' do
+    result = command.execute
+    expect(result[:encoding]).to eq('UTF-8')
+    expect(result[:translation_count]).to eq(8)
+    expect(result[:base_64_encoded]).to eq(false)
+    expect(result[:locale]).to eq(locales.first)
+    expect(result[:paths]).to eq([])
+    expect(result).to_not include(:checksum)
+  end
+
+  context 'with base 64 encoding option' do
+    before do
+      command.set_base_64_encode(true)
+    end
+
+    it 'base 64 encodes the payload' do
+      result = command.execute
+      expect(Base64.decode64(result[:payload])).to include(
+        "I'm a little teapot = i'may aay ittlelay eapottay"
+      )
+    end
+  end
+
+  context 'with checksum option' do
+    before do
+      command.set_include_checksum(true)
+    end
+
+    it 'includes a checksum with the payload' do
+      expect(command.execute).to include(:checksum)
+    end
+  end
+
+  context 'with snapshot option' do
+    before do
+      command.set_include_snapshot(true)
+    end
+
+    it 'includes the snapshot' do
+      expect(command.execute[:snapshot]).to eq(
+        'first_file.txt' => commit_id,
+        'folder/second_file.txt' => commit_id,
+        'folder/with_metakeys.txt' => commit_id
+      )
+    end
+  end
+
+  context 'with a different encoding' do
+    before do
+      command.set_encoding(Encoding::UTF_16)
+    end
+
+    it 'includes the encoding alongside the payload' do
+      expect(command.execute[:encoding]).to eq('UTF-16')
+    end
+  end
+end

data/spec/core/commands/translations/translation_lookup_command_spec.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core::Commands
+include Rosette::DataStores
+include Rosette::Core
+
+describe TranslationLookupCommand do
+  let(:repo_name) { 'single_commit' }
+
+  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_locale('de-DE')
+    end
+  end
+
+  let(:locale) { repo_config.locales.first }
+  let(:commit_id) { fixture.repo.git('rev-parse HEAD').strip }
+  let(:repo_config) { fixture.config.get_repo(repo_name) }
+  let(:rosette_config) { fixture.config }
+  let(:command) do
+    TranslationLookupCommand.new(rosette_config)
+      .set_repo_name(repo_name)
+      .set_locale('de-DE')
+      .set_commit_id(commit_id)
+  end
+
+  describe '#execute' do
+    let!(:phrase1) do
+      InMemoryDataStore::Phrase.create(
+        key: 'sweet phrase', meta_key: 'sweet.phrase',
+        repo_name: repo_name, commit_id: commit_id
+      )
+    end
+
+    let!(:phrase2) do
+      InMemoryDataStore::Phrase.create(
+        key: 'perfect phrase', meta_key: 'perfect.phrase',
+        repo_name: repo_name, commit_id: commit_id
+      )
+    end
+
+    it 'looks up the translation string' do
+      repo_config.tms.store_phrases([phrase1, phrase2], commit_id)
+      repo_config.tms.auto_translate(locale, phrase1)
+      repo_config.tms.auto_translate(locale, phrase2)
+
+      command.set_meta_key(phrase1.meta_key)
+      expect(command.execute).to eq('eetsway asephray')
+
+      command.set_meta_key(phrase2.meta_key)
+      expect(command.execute).to eq('erfectpay asephray')
+    end
+  end
+end

data/spec/core/configurator_spec.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe Configurator do
+  let(:config) { Configurator.new }
+
+  describe '#add_repo' do
+    it 'yields and adds a repo config' do
+      config.add_repo('foo') do |repo_config|
+        expect(repo_config).to be_a(Rosette::Core::RepoConfig)
+        expect(repo_config.name).to eq('foo')
+      end
+    end
+  end
+
+  describe '#get_repo' do
+    it 'returns the repo by name' do
+      config.add_repo('foo') {}
+      config.get_repo('foo').tap do |repo|
+        expect(repo.name).to eq('foo')
+      end
+    end
+  end
+
+  describe '#use_datastore' do
+    it 'attempts to look up the datastore constant if passed a string' do
+      config.use_datastore('test')
+      expect(config.datastore).to be_a(Rosette::DataStores::TestDataStore)
+    end
+
+    it 'uses the passed in value directly if not passed a string (should be a constant, fyi)' do
+      config.use_datastore(Rosette::DataStores::TestDataStore)
+      expect(config.datastore).to be_a(Rosette::DataStores::TestDataStore)
+    end
+
+    it "raises an error if the object passed isn't a String or Class" do
+      expect(lambda { config.use_datastore(1) }).to raise_error(ArgumentError)
+    end
+
+    it "raises an error if the datastore couldn't be looked up" do
+      expect(lambda { config.use_datastore('foo') }).to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/core/error_reporters/buffered_error_reporter_spec.rb

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe BufferedErrorReporter do
+  let(:error) { StandardError.new('jelly beans') }
+  let(:options) { { foo: 'bar' } }
+  let(:reporter) { BufferedErrorReporter.new }
+
+  describe '#report_error' do
+    it 'should log each error' do
+      reporter.report_error(error, options)
+      expect(reporter.errors.size).to eq(1)
+
+      reporter.errors.first.tap do |err|
+        expect(err.keys).to eq([:error, :options])
+        expect(err[:error]).to eq(error)
+        expect(err[:options]).to eq(options)
+      end
+    end
+  end
+
+  context 'with a reported error' do
+    before(:each) do
+      reporter.report_error(error, options)
+    end
+
+    describe '#reset' do
+      it 'should clear the error list' do
+        reporter.reset
+        expect(reporter.errors).to be_empty
+      end
+    end
+
+    describe '#errors_found?' do
+      it 'returns true if errors have been reported, false otherwise' do
+        expect(reporter.errors_found?).to be_truthy
+        reporter.reset
+        expect(reporter.errors_found?).to be_falsey
+      end
+    end
+
+    describe '#each_error' do
+      it 'yields each error if given a block' do
+        reporter.each_error do |cur_error, opts|
+          expect(cur_error).to eq(error)
+          expect(opts).to eq(options)
+        end
+      end
+
+      it 'returns an enumerator if not given a block' do
+        reporter.each_error.tap do |enum|
+          expect(enum).to be_a(Enumerator)
+          expect(enum.to_a).to include([error, options])
+        end
+      end
+    end
+  end
+end

data/spec/core/error_reporters/nil_error_reporter_spec.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe NilErrorReporter do
+  let(:error) { StandardError.new('jelly beans') }
+  let(:reporter) { NilErrorReporter.instance }
+
+  describe '#report_error' do
+    it 'should respond to the #report_error method' do
+      reporter.report_error(error)
+    end
+  end
+end

data/spec/core/error_reporters/printing_error_reporter_spec.rb

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe PrintingErrorReporter do
+  class Collector
+    attr_reader :messages
+
+    def initialize
+      @messages = []
+    end
+
+    def write(message)
+      @messages << message
+    end
+  end
+
+  let(:error) do
+    begin
+      raise StandardError, 'jelly beans'
+    rescue => e
+      e
+    end
+  end
+
+  let(:collector) { Collector.new }
+  let(:reporter) { PrintingErrorReporter.new(collector) }
+  let(:options) { { foo: 'bar' } }
+
+  describe '#report_error' do
+    it 'prints the error message' do
+      reporter.report_error(error, options)
+      expect(collector.messages.size).to eq(1)
+      expect(collector.messages).to include("jelly beans\n")
+    end
+
+    context 'with a reporter that prints a stack trace' do
+      let(:reporter) do
+        PrintingErrorReporter.new(
+          collector, print_stack_trace: true
+        )
+      end
+
+      it 'prints a stack trace along with the error message' do
+        reporter.report_error(error, options)
+        expect(collector.messages).to include("jelly beans\n")
+        expect(collector.messages).to include(options.inspect)
+        expect(collector.messages.size).to be > 1
+
+        trace_message = collector.messages.find do |message|
+          message =~ /printing_error_reporter_spec.rb:[\d]+/
+        end
+
+        expect(trace_message).to_not be_nil
+      end
+    end
+  end
+end

data/spec/core/extractor/commit_log_status_spec.rb

@@ -0,0 +1,216 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+include Rosette::DataStores
+
+class CommitLogStatusTester
+  include CommitLogStatus
+
+  def initialize(initial_status)
+    send('status=', initial_status)
+  end
+
+  def status=(new_status)
+    if new_status
+      @status = new_status
+
+      aasm.set_current_state_with_persistence(
+        new_status.to_sym
+      )
+    end
+  end
+
+  def status
+    aasm.current_state.to_s
+  end
+end
+
+describe CommitLogStatus do
+  let(:instance) do
+    CommitLogStatusTester.new(status)
+  end
+
+  context 'with a NOT_SEEN status' do
+    let(:status) { PhraseStatus::NOT_SEEN }
+
+    describe 'on fetch' do
+      it 'transitions to FETCHED' do
+        expect(instance.fetch).to be_truthy
+        expect(instance.status).to eq(PhraseStatus::FETCHED)
+      end
+    end
+
+    describe 'on extract' do
+      it 'raises an error' do
+        expect { instance.extract }.to raise_error(AASM::InvalidTransition)
+      end
+    end
+
+    describe 'on push' do
+      it 'raises an error' do
+        expect { instance.push }.to raise_error(AASM::InvalidTransition)
+      end
+    end
+
+    describe 'on finalize' do
+      it 'raises an error' do
+        expect { instance.finalize }.to raise_error(AASM::InvalidTransition)
+      end
+    end
+
+    describe 'on missing' do
+      it 'transitions to MISSING' do
+        expect(instance.missing).to be_truthy
+        expect(instance.status).to eq(PhraseStatus::MISSING)
+      end
+    end
+  end
+
+  context 'with a FETCHED status' do
+    let(:status) { PhraseStatus::FETCHED }
+
+    describe 'on fetch' do
+      it 'raises an error' do
+        expect { instance.fetch }.to raise_error(AASM::InvalidTransition)
+      end
+    end
+
+    describe 'on extract' do
+      it 'transitions to EXTRACTED' do
+        expect(instance.extract).to be_truthy
+        expect(instance.status).to eq(PhraseStatus::EXTRACTED)
+      end
+    end
+
+    describe 'on push' do
+      it 'raises an error' do
+        expect { instance.push }.to raise_error(AASM::InvalidTransition)
+      end
+    end
+
+    describe 'on finalize' do
+      it 'raises an error' do
+        expect { instance.finalize }.to raise_error(AASM::InvalidTransition)
+      end
+    end
+
+    describe 'on missing' do
+      it 'transitions to MISSING' do
+        expect(instance.missing).to be_truthy
+        expect(instance.status).to eq(PhraseStatus::MISSING)
+      end
+    end
+  end
+
+  context 'with an EXTRACTED status' do
+    let(:status) { PhraseStatus::EXTRACTED }
+
+    describe 'on fetch' do
+      it 'raises an error' do
+        expect { instance.fetch }.to raise_error(AASM::InvalidTransition)
+      end
+    end
+
+    describe 'on extract' do
+      it 'raises an error' do
+        expect { instance.extract }.to raise_error(AASM::InvalidTransition)
+      end
+    end
+
+    describe 'on push' do
+      it 'transitions to PUSHED' do
+        expect(instance.push).to be_truthy
+        expect(instance.status).to eq(PhraseStatus::PUSHED)
+      end
+    end
+
+    describe 'on finalize' do
+      it 'transitions to FINALIZED' do
+        expect(instance.finalize).to be_truthy
+        expect(instance.status).to eq(PhraseStatus::FINALIZED)
+      end
+    end
+
+    describe 'on missing' do
+      it 'transitions to MISSING' do
+        expect(instance.missing).to be_truthy
+        expect(instance.status).to eq(PhraseStatus::MISSING)
+      end
+    end
+  end
+
+  context 'with a PUSHED status' do
+    let(:status) { PhraseStatus::PUSHED }
+
+    describe 'on fetch' do
+      it 'raises an error' do
+        expect { instance.fetch }.to raise_error(AASM::InvalidTransition)
+      end
+    end
+
+    describe 'on extract' do
+      it 'raises an error' do
+        expect { instance.extract }.to raise_error(AASM::InvalidTransition)
+      end
+    end
+
+    describe 'on push' do
+      it 'stays PUSHED' do
+        expect(instance.push).to be_truthy
+        expect(instance.status).to eq(PhraseStatus::PUSHED)
+      end
+    end
+
+    describe 'on finalize' do
+      it 'transitions to FINALIZED' do
+        expect(instance.finalize).to be_truthy
+        expect(instance.status).to eq(PhraseStatus::FINALIZED)
+      end
+    end
+
+    describe 'on missing' do
+      it 'transitions to MISSING' do
+        expect(instance.missing).to be_truthy
+        expect(instance.status).to eq(PhraseStatus::MISSING)
+      end
+    end
+  end
+
+  context 'with a FINALIZED status' do
+    let(:status) { PhraseStatus::FINALIZED }
+
+    describe 'on fetch' do
+      it 'raises an error' do
+        expect { instance.fetch }.to raise_error(AASM::InvalidTransition)
+      end
+    end
+
+    describe 'on extract' do
+      it 'raises an error' do
+        expect { instance.extract }.to raise_error(AASM::InvalidTransition)
+      end
+    end
+
+    describe 'on push' do
+      it 'raises an error' do
+        expect { instance.push }.to raise_error(AASM::InvalidTransition)
+      end
+    end
+
+    describe 'on finalize' do
+      it 'stays FINALIZED' do
+        expect(instance.finalize).to be_truthy
+        expect(instance.status).to eq(PhraseStatus::FINALIZED)
+      end
+    end
+
+    describe 'on missing' do
+      it 'transitions to MISSING' do
+        expect(instance.missing).to be_truthy
+        expect(instance.status).to eq(PhraseStatus::MISSING)
+      end
+    end
+  end
+end