leda 0.0.1

data/lib/leda/version.rb

@@ -0,0 +1,3 @@
+module Leda
+  VERSION = "0.0.1"
+end

data/spec/leda/configuration_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+module Leda
+  describe Configuration do
+    let(:configuration) { Configuration.new }
+
+    describe 'defined from DSL' do
+      let(:actual) do
+        Configuration.new do |leda|
+          leda.data_unit 'providers' do |c|
+            c.postgresql tables: %w(practices offices practitioners)
+            c.elasticsearch indexes: %w(sst-practitioners)
+          end
+
+          leda.data_unit 'groups' do |c|
+            c.postgresql tables: %w(groups mentioned practitioners)
+          end
+        end
+      end
+
+      it 'produces the expected data units' do
+        expect(actual.data_units.map(&:name)).to eq(%w(providers groups))
+      end
+
+      it 'produces appropriate stores for each data unit' do
+        providers_data_unit = actual.data_units.first
+
+        expect(providers_data_unit.stores.map(&:class)).
+          to eq([Stores::Postgresql, Stores::Elasticsearch])
+      end
+
+      it 'passes the configuration parameters to each store' do
+        providers_postgresql_store = actual.data_units.first.stores.first
+
+        expect(providers_postgresql_store.options).to eq({ tables: %w(practices offices practitioners) })
+      end
+    end
+
+    describe '#update' do
+      it 'adds to the existing configuration' do
+        configuration.update do |leda|
+          leda.data_unit 'lookups' do |d|
+            d.postgresql tables: %w(zip_codes)
+          end
+        end
+
+        configuration.update do |leda|
+          leda.data_unit 'people' do |d|
+            d.postgresql tables: %w(people phone_numbers street_addresses)
+          end
+        end
+
+        expect(configuration.data_units.map(&:name)).to eq(%w(lookups people))
+      end
+
+      it 'returns the configuration' do
+        expect(configuration.update { }).to eql(configuration)
+      end
+    end
+
+    describe '#project_root_dir=' do
+      it 'coerces a string into a Pathname' do
+        configuration.project_root_dir = '/foo/quux'
+
+        expect(configuration.project_root_dir).to eq(Pathname.new('/foo/quux'))
+      end
+
+      it 'leaves a Pathname alone' do
+        configuration.project_root_dir = Pathname.new('/bar/baz')
+        expect(configuration.project_root_dir).to eq(Pathname.new('/bar/baz'))
+      end
+    end
+
+    describe '#base_path' do
+      it 'defaults to db/leda' do
+        expect(configuration.base_path).to eq(Pathname.new('db/leda'))
+      end
+    end
+
+    describe '#base_path=' do
+      it 'coerces a string into a Pathname' do
+        configuration.base_path = 'foo/quux'
+
+        expect(configuration.base_path).to eq(Pathname.new('foo/quux'))
+      end
+
+      it 'leaves a Pathname alone' do
+        configuration.base_path = Pathname.new('bar/baz')
+        expect(configuration.base_path).to eq(Pathname.new('bar/baz'))
+      end
+    end
+
+    describe '#base_dir' do
+      it 'is the combination of the project root and the base path' do
+        configuration.project_root_dir = '/app-root'
+        configuration.base_path = 'db-data'
+        expect(configuration.base_dir).to eq(Pathname.new('/app-root/db-data'))
+      end
+    end
+  end
+end

data/spec/leda/rake_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'rake'
+
+module Leda
+  describe Rake do
+    let(:configuration) {
+      Configuration.new do |leda|
+        leda.data_unit 'tlus' do |du|
+          du.mock_c
+        end
+
+        leda.data_unit 'people' do |du|
+          du.mock_a
+          du.mock_b
+        end
+      end
+    }
+
+    before do
+      ::Rake.application = ::Rake::Application.new
+      Leda::Rake.define_tasks(configuration, [:outside_prereq])
+    end
+
+    after do
+      ::Rake.application.clear
+    end
+
+    shared_examples 'a Leda task' do
+      it 'exists' do
+        expect { task }.to_not raise_error
+      end
+
+      it 'has a description' do
+        expect(task.comment).not_to be_nil
+      end
+
+      it 'depends on the supplied prereqs' do
+        expect(task.prerequisites).to eq(%w(outside_prereq))
+      end
+    end
+
+    shared_examples 'a restore_from task' do
+      it_behaves_like 'a Leda task'
+
+      it 'has a source_env argument' do
+        expect(task.arg_names).to eq([:source_env])
+      end
+    end
+
+    describe 'the all:dump task' do
+      let(:task) { ::Rake::Task['dump'] }
+
+      it_behaves_like 'a Leda task'
+    end
+
+    describe 'an individual unit dump task' do
+      let(:task) { ::Rake::Task['people:dump'] }
+
+      it_behaves_like 'a Leda task'
+    end
+
+    describe 'an individual store dump task' do
+      let(:task) { ::Rake::Task['tlus:mock_c:dump'] }
+
+      it_behaves_like 'a Leda task'
+    end
+
+    describe 'the all:restore_from task' do
+      let(:task) { ::Rake::Task['restore_from'] }
+
+      it_behaves_like 'a restore_from task'
+    end
+
+    describe 'an individual unit restore_from task' do
+      let(:task) { ::Rake::Task['tlus:restore_from'] }
+
+      it_behaves_like 'a restore_from task'
+    end
+
+    describe 'an individual store restore_from task' do
+      let(:task) { ::Rake::Task['people:mock_b:restore_from'] }
+
+      it_behaves_like 'a restore_from task'
+    end
+  end
+end

data/spec/leda/runner_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+module Leda
+  describe Runner do
+    let(:root) { spec_tmpdir }
+    let(:root_s) { root.to_s }
+
+    let(:configuration) {
+      Configuration.new do |leda|
+        leda.project_root_dir = root
+        leda.base_path = 'base'
+
+        leda.data_unit 'tlus' do |du|
+          du.mock_c
+          du.mock_b
+        end
+
+        leda.data_unit 'people' do |du|
+          du.mock_a
+          du.mock_b
+        end
+      end
+    }
+
+    let(:runner) { Runner.new('dev', configuration) }
+
+    describe '#dump' do
+      let(:actual_calls) {
+        calls = []
+        configuration.data_units.each do |data_unit|
+          data_unit.stores.each do |store|
+            unless store.dump_directories.empty?
+              calls << [data_unit.name, store.name, store.dump_directories.map(&:to_s)]
+            end
+          end
+        end
+        calls
+      }
+
+      describe 'with no args' do
+        before do
+          runner.dump
+        end
+
+        it 'runs dump on every configured store' do
+          expect(actual_calls).to eq([
+            ['tlus', 'mock_c', [root_s + '/base/dev/tlus/mock_c']],
+            ['tlus', 'mock_b', [root_s + '/base/dev/tlus/mock_b']],
+            ['people', 'mock_a', [root_s + '/base/dev/people/mock_a']],
+            ['people', 'mock_b', [root_s + '/base/dev/people/mock_b']]
+          ])
+        end
+      end
+
+      describe 'with just a data unit name' do
+        before do
+          runner.dump('people')
+        end
+
+        it 'runs dump on every store in that unit' do
+          expect(actual_calls).to eq([
+            ['people', 'mock_a', [root_s + '/base/dev/people/mock_a']],
+            ['people', 'mock_b', [root_s + '/base/dev/people/mock_b']]
+          ])
+        end
+      end
+
+      describe 'with just a store name' do
+        before do
+          runner.dump(nil, 'mock_b')
+        end
+
+        it 'runs dump on every store of that type' do
+          expect(actual_calls).to eq([
+            ['tlus', 'mock_b', [root_s + '/base/dev/tlus/mock_b']],
+            ['people', 'mock_b', [root_s + '/base/dev/people/mock_b']]
+          ])
+        end
+      end
+
+      describe 'with both a data unit and a store name' do
+        before do
+          runner.dump('tlus', 'mock_b')
+        end
+
+        it 'runs dump on just that combination' do
+          expect(actual_calls).to eq([
+            ['tlus', 'mock_b', [root_s + '/base/dev/tlus/mock_b']]
+          ])
+        end
+      end
+
+      describe 'with an unknown data unit' do
+        it 'throws an exception' do
+          expect { runner.dump('frogs', 'mock_a') }.to raise_error(/No data configured that matches frogs:mock_a/)
+        end
+      end
+
+      describe 'with an unused or unknown store' do
+        it 'throws an exception' do
+          expect { runner.dump('people', 'mock_c') }.to raise_error(/No data configured that matches people:mock_c/)
+        end
+      end
+    end
+
+    describe '#dump_relative_paths' do
+      it 'returns the set of paths for the selected parameters' do
+        expect(runner.dump_relative_paths('people').map(&:to_s)).to eq([
+          'base/dev/people/mock_a',
+          'base/dev/people/mock_b'
+        ])
+      end
+    end
+
+    describe '#restore_from' do
+      let(:actual_calls) {
+        calls = []
+        configuration.data_units.each do |data_unit|
+          data_unit.stores.each do |store|
+            unless store.restore_from_directories.empty?
+              calls << [data_unit.name, store.name, store.restore_from_directories.map(&:to_s)]
+            end
+          end
+        end
+        calls
+      }
+
+      describe 'with no args' do
+        before do
+          runner.restore_from('prod')
+        end
+
+        it 'runs restore_from on every configured store' do
+          expect(actual_calls).to eq([
+            ['tlus', 'mock_c', [root_s + '/base/prod/tlus/mock_c']],
+            ['tlus', 'mock_b', [root_s + '/base/prod/tlus/mock_b']],
+            ['people', 'mock_a', [root_s + '/base/prod/people/mock_a']],
+            ['people', 'mock_b', [root_s + '/base/prod/people/mock_b']]
+          ])
+        end
+      end
+
+      describe 'with just a data unit name' do
+        before do
+          runner.restore_from('stg', 'people')
+        end
+
+        it 'runs restore_from on every store in that unit' do
+          expect(actual_calls).to eq([
+            ['people', 'mock_a', [root_s + '/base/stg/people/mock_a']],
+            ['people', 'mock_b', [root_s + '/base/stg/people/mock_b']]
+          ])
+        end
+      end
+
+      describe 'with just a store name' do
+        before do
+          runner.restore_from('local', nil, 'mock_b')
+        end
+
+        it 'runs restore_from on every store of that type' do
+          expect(actual_calls).to eq([
+            ['tlus', 'mock_b', [root_s + '/base/local/tlus/mock_b']],
+            ['people', 'mock_b', [root_s + '/base/local/people/mock_b']]
+          ])
+        end
+      end
+
+      describe 'with both a data unit and a store name' do
+        before do
+          runner.restore_from('super-prod', 'tlus', 'mock_b')
+        end
+
+        it 'runs restore_from on just that combination' do
+          expect(actual_calls).to eq([
+            ['tlus', 'mock_b', [root_s + '/base/super-prod/tlus/mock_b']]
+          ])
+        end
+      end
+
+      describe 'with an unknown data unit' do
+        it 'throws an exception' do
+          expect { runner.restore_from('prod', 'frogs', 'mock_a') }.to raise_error(/No data configured that matches frogs:mock_a/)
+        end
+      end
+
+      describe 'with an unused or unknown store' do
+        it 'throws an exception' do
+          expect { runner.restore_from('prod', 'people', 'mock_c') }.to raise_error(/No data configured that matches people:mock_c/)
+        end
+      end
+    end
+  end
+end

data/spec/leda/version_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Leda, "::VERSION" do
+  it "exists" do
+    expect { Leda::VERSION }.not_to raise_error
+  end
+
+  it "has 3 or 4 dot separated parts" do
+    expect(Leda::VERSION.split('.').size).to be_between(3, 4)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rspec'
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require 'leda'
+
+Dir[File.expand_path('../support/*.rb', __FILE__)].each do |support|
+  require support
+end
+
+RSpec.configure do |config|
+  config.include Leda::Spec::Tmpdir
+
+  config.after { rm_tmpdir }
+end

data/spec/support/recording_store.rb

@@ -0,0 +1,29 @@
+class RecordingStore
+  include Leda::Store
+
+  def dump_directories
+    @dump_directories ||= []
+  end
+
+  def restore_from_directories
+    @restore_from_directories ||= []
+  end
+
+  def dump(directory)
+    dump_directories << directory
+  end
+
+  def restore_from(directory)
+    restore_from_directories << directory
+  end
+end
+
+%w(mock_a mock_b mock_c).each do |mock_name|
+  store = Class.new(RecordingStore)
+  store.class_eval <<-DEF
+    def name
+      #{mock_name.inspect}
+    end
+  DEF
+  Leda::Store.register_store(store, mock_name)
+end

data/spec/support/tmpdir.rb

@@ -0,0 +1,18 @@
+require 'pathname'
+
+module Leda::Spec
+  module Tmpdir
+    def spec_tmpdir(path=nil)
+      @spec_tmpdir ||= Pathname.new(File.expand_path("../../spec/tmp", __FILE__))
+      full = path ? @spec_tmpdir.join(path) : @spec_tmpdir
+      full.mkpath
+      full
+    end
+
+    def rm_tmpdir
+      if @spec_tempdir
+        @spec_tempdir.rmtree
+      end
+    end
+  end
+end