rosette-core 1.0.1

data/spec/core/validators/commit_validator_spec.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+include Rosette::Core::Validators
+
+describe CommitValidator do
+  let(:repo_name) { 'double_commit' }
+  let(:fixture) { load_repo_fixture(repo_name) }
+  let(:validator) { CommitValidator.new }
+
+  let(:config) do
+    Rosette.build_config do |config|
+      config.add_repo(repo_name) do |repo_config|
+        repo_config.set_path(fixture.working_dir.join('.git').to_s)
+      end
+    end
+  end
+
+  let(:shas) do
+    fixture.git('rev-list --all').split("\n")
+  end
+
+  describe '#valid?' do
+    it 'returns true if the commit exists' do
+      shas.each do |sha|
+        expect(validator.valid?(sha, repo_name, config)).to be_truthy
+      end
+    end
+
+    it "returns false if the commit doesn't exist" do
+      expect(validator.valid?('123abc', repo_name, config)).to be_falsy
+    end
+
+    it "returns false if the repo can't be found" do
+      expect(validator.valid?(shas.first, 'foobar', config)).to be_falsy
+    end
+  end
+end

data/spec/core/validators/encoding_validator_spec.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+include Rosette::Core::Validators
+
+describe EncodingValidator do
+  let(:repo_name) { 'double_commit' }
+  let(:fixture) { load_repo_fixture(repo_name) }
+  let(:validator) { EncodingValidator.new }
+
+  let(:config) do
+    Rosette.build_config do |config|
+      config.add_repo(repo_name) do |repo_config|
+        repo_config.set_path(fixture.working_dir.join('.git').to_s)
+      end
+    end
+  end
+
+  describe '#valid?' do
+    it 'returns true if the encoding is valid' do
+      expect(validator.valid?('UTF-8', repo_name, config)).to be_truthy
+    end
+
+    it 'returns false if the encoding is not valid' do
+      expect(validator.valid?('FOO', repo_name, config)).to be_falsy
+    end
+  end
+end

data/spec/core/validators/locale_validator_spec.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+include Rosette::Core::Validators
+
+describe LocaleValidator do
+  let(:repo_name) { 'double_commit' }
+  let(:fixture) { load_repo_fixture(repo_name) }
+  let(:validator) { LocaleValidator.new }
+
+  let(:config) do
+    Rosette.build_config do |config|
+      config.add_repo(repo_name) do |repo_config|
+        repo_config.set_path(fixture.working_dir.join('.git').to_s)
+        repo_config.add_locale('es-MX')
+      end
+    end
+  end
+
+  describe '#valid?' do
+    it 'returns true if the locale exists in the list of configured locales' do
+      expect(validator.valid?('es-MX', repo_name, config)).to be_truthy
+    end
+
+    it "returns false if the locale doesn't exist in the list of configured locales" do
+      expect(validator.valid?('xx', repo_name, config)).to be_falsy
+    end
+  end
+end

data/spec/core/validators/repo_validator_spec.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+include Rosette::Core::Validators
+
+describe RepoValidator do
+  let(:repo_name) { 'double_commit' }
+  let(:fixture) { load_repo_fixture(repo_name) }
+  let(:validator) { RepoValidator.new }
+
+  let(:config) do
+    Rosette.build_config do |config|
+      config.add_repo(repo_name) do |repo_config|
+        repo_config.set_path(fixture.working_dir.join('.git').to_s)
+      end
+    end
+  end
+
+  describe '#valid?' do
+    it 'returns true if the repo exists' do
+      expect(validator.valid?(repo_name, repo_name, config)).to be_truthy
+    end
+
+    it "returns false if the repo doesn't exist" do
+      expect(validator.valid?('foobar', repo_name, config)).to be_falsy
+    end
+  end
+end

data/spec/core/validators/serializer_validator_spec.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+include Rosette::Core::Validators
+
+describe SerializerValidator do
+  let(:repo_name) { 'double_commit' }
+  let(:fixture) { load_repo_fixture(repo_name) }
+  let(:validator) { SerializerValidator.new }
+
+  let(:config) do
+    Rosette.build_config do |config|
+      config.add_repo(repo_name) do |repo_config|
+        repo_config.set_path(fixture.working_dir.join('.git').to_s)
+        repo_config.add_serializer('my_serializer', format: 'test/test')
+      end
+    end
+  end
+
+  describe '#valid?' do
+    it 'returns true if the serializer exists' do
+      expect(validator.valid?('test/test', repo_name, config)).to be_truthy
+    end
+
+    it "returns false if the serializer doesn't exist" do
+      expect(validator.valid?('foo/bar', repo_name, config)).to be_falsy
+    end
+  end
+end

data/spec/integrations/integratable_spec.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Integrations
+
+class IntegratableTestClass
+  include Integratable
+end
+
+describe Integratable do
+  let(:instance) { IntegratableTestClass.new }
+
+  describe '#add_integration' do
+    it 'resolves the integration id and adds the integration to the list' do
+      instance.add_integration('test/test')
+      instance.integrations.first.tap do |integration|
+        expect(integration).to be_a(Test::TestIntegration)
+      end
+    end
+
+    it 'yields a configurator' do
+      instance.add_integration('test/test') do |integration_config|
+        expect(integration_config).to be_a(Test::TestIntegration::Configurator)
+        integration_config.set_test_property('foobar')
+      end
+
+      instance.integrations.first.tap do |integration|
+        expect(integration.configuration.test_property).to eq('foobar')
+      end
+    end
+  end
+
+  describe '#get_integration' do
+    it 'returns the integration instance by id' do
+      instance.add_integration('test/test')
+      instance.get_integration('test/test').tap do |integration|
+        expect(integration).to be_a(Test::TestIntegration)
+      end
+    end
+
+    it "returns nil if the integration hasn't been configured" do
+      expect(instance.get_integration('test/test')).to be_nil
+    end
+
+    it "returns nil if the integration doesn't exist" do
+      expect(instance.get_integration('foo/bar')).to be_nil
+    end
+  end
+
+  describe '#apply_integrations' do
+    it 'iterates over the list of integrations and applies them to the given object' do
+      instance.add_integration('test/test')
+      expect(instance.integrations.first).to receive(:integrate).with(:integratable)
+      instance.apply_integrations(:integratable)
+    end
+  end
+end

data/spec/queuing/commits/commit_conductor_spec.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Queuing::Commits
+include Rosette::Queuing
+include Rosette::DataStores
+
+describe CommitConductor 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')
+      config.use_queue('test')
+    end
+  end
+
+  let(:rosette_config) { fixture.config }
+  let(:logger) { NullLogger.new }
+
+  let(:conductor) { CommitConductor.new(rosette_config, repo_name, logger) }
+
+  before(:each) do
+    allow(CommitConductor).to receive(:stage_classes).and_return(
+      [FakeCommitStage]
+    )
+  end
+
+  describe '#enqueue' do
+    it 'adds a new commit job to the queue' do
+      expect { conductor.enqueue(commit_id) }.to(
+        change { TestQueue::Queue.list.size }.from(0).to(1)
+      )
+
+      job = TestQueue::Queue.list.first
+      expect(job.repo_name).to eq(repo_name)
+      expect(job.commit_id).to eq(commit_id)
+    end
+  end
+
+  describe '#advance' 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
+
+    it 'finds the correct stage, executes it, and enqueues the next stage' do
+      expect { conductor.advance(commit_log) }.to(
+        change { TestQueue::Queue.list.size }.from(0).to(1)
+      )
+
+      expect(commit_log.status).to eq('fake_stage_updated_me')
+    end
+
+    it 'does not enqueue a new job if the commit is finished' do
+      expect(conductor).to receive(:finished?).and_return(true)
+
+      expect { conductor.advance(commit_log) }.to_not(
+        change { TestQueue::Queue.list.size }.from(0)
+      )
+    end
+  end
+end

data/spec/queuing/commits/commit_job_spec.rb

@@ -0,0 +1,87 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Queuing::Commits
+include Rosette::Queuing
+include Rosette::DataStores
+
+describe CommitJob do
+  let(:repo_name) { 'single_commit' }
+  let(:commit_id) { fixture.repo.git('rev-parse HEAD').strip }
+  let(:status) { PhraseStatus::FETCHED }
+
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      config.use_datastore('in-memory')
+      config.use_queue('test')
+    end
+  end
+
+  let(:rosette_config) { fixture.config }
+  let(:repo_config) { fixture.config.get_repo(repo_name) }
+  let(:logger) { NullLogger.new }
+
+  let(:commit_log) do
+    entry = InMemoryDataStore::CommitLog.entries.find do |entry|
+      entry.commit_id == commit_id
+      entry.repo_name == repo_name
+    end
+
+    entry || InMemoryDataStore::CommitLog.create(
+      status: status,
+      repo_name: repo_name,
+      commit_id: commit_id,
+      phrase_count: 0,
+      commit_datetime: nil
+    )
+  end
+
+  let(:job) do
+    CommitJob.new(repo_name, commit_id, status)
+  end
+
+  before(:each) do
+    allow(CommitConductor).to receive(:stage_classes).and_return(
+      [FakeCommitStage]
+    )
+  end
+
+  describe 'from_stage' do
+    it 'instantiates a job with information from the stage' do
+      stage = FetchStage.new(rosette_config, repo_config, logger, commit_log)
+      CommitJob.from_stage(stage).tap do |job|
+        expect(job.repo_name).to eq(repo_name)
+        expect(job.commit_id).to eq(commit_id)
+        expect(job.status).to eq(commit_log.status)
+      end
+    end
+  end
+
+  describe '#to_args' do
+    it 'creates an array of serializable arguments' do
+      expect(job.to_args).to eq([repo_name, commit_id, commit_log.status])
+    end
+  end
+
+  describe '#work' do
+    it 'looks up the commit log and advances it to the next stage' do
+      expect { job.work(rosette_config, logger) }.to(
+        change { TestQueue::Queue.list.size }
+      )
+
+      expect(commit_log.status).to eq('fake_stage_updated_me')
+    end
+
+    it 'creates a commit log if one does not already exist' do
+      InMemoryDataStore::CommitLog.entries.clear
+
+      expect { job.work(rosette_config, logger) }.to(
+        change { InMemoryDataStore::CommitLog.entries.size }.from(0).to(1)
+      )
+
+      entry = InMemoryDataStore::CommitLog.entries.first
+      expect(entry.status).to eq('fake_stage_updated_me')
+    end
+  end
+end

data/spec/queuing/commits/extract_stage_spec.rb

@@ -0,0 +1,68 @@
+# 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::FETCHED,
+      repo_name: repo_name,
+      commit_id: commit_id,
+      phrase_count: 0,
+      commit_datetime: nil,
+      branch_name: 'refs/heads/master'
+    )
+  end
+
+  let(:stage) do
+    ExtractStage.new(rosette_config, repo_config, logger, commit_log)
+  end
+
+  describe '#execute!' do
+    it 'extracts phrases' do
+      stage.execute!
+      phrases = InMemoryDataStore::Phrase.entries.map(&:key)
+      expect(phrases).to include("I'm a little teapot")
+      expect(phrases).to include("Diamonds are a girl's best friend.")
+      expect(phrases).to include(' test string 1')
+    end
+
+    it 'updates the commit log status' do
+      stage.execute!
+      expect(commit_log.status).to eq(PhraseStatus::EXTRACTED)
+    end
+
+    it "updates the status to MISSING if the commit 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