hexx-storage 0.0.2

data/lib/hexx/storage/version.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Hexx
+
+  module Storage
+
+    # The semantic version of the module.
+    # @see http://semver.org/ Semantic versioning 2.0
+    VERSION = "0.0.2".freeze
+
+  end # module Storage
+
+end # module Hexx

data/spec/integration/storage.yml

@@ -0,0 +1,9 @@
+---
+foo:
+  bar:
+    adapter: :memory
+  baz:
+    adapter:  :sql
+    uri:      "postgres://localhost/rom"
+    user:     "postgres"
+    log:      "tmp/baz.log"

data/spec/integration/storage_spec.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require "rom/memory"
+require "rom-sql"
+require "sequel/adapters/postgres"
+
+describe "Loading a storage" do
+
+  let(:migrate) { File.expand_path "../migrate", __FILE__ }
+  let(:tmp)     { File.expand_path "../tmp", __FILE__     }
+  before do
+    `mkdir #{ migrate } -p`
+    `mkdir #{ tmp } -p`
+  end
+
+  let(:storage) { Hexx::Storage.setup }
+
+  before do
+    storage.root = File.expand_path "..", __FILE__
+    storage.load "storage.yml", env: "foo"
+    storage[:baz].migrations = migrate
+
+    ROM.setup storage.settings
+    ROM.finalize
+
+    storage.each do |key, value|
+      next unless value.logger
+      ROM.env.repositories[key].use_logger value.logger
+    end
+  end
+
+  subject { ROM.env.repositories }
+
+  it "sets repositories" do
+    expect(subject.keys).to eq %i(bar baz)
+    expect(subject[:bar]).to be_kind_of ROM::Memory::Repository
+    expect(subject[:baz]).to be_kind_of ROM::SQL::Repository
+  end
+
+  it "sets loggers" do
+    expect(subject[:bar].logger).to be_nil
+    expect(subject[:baz].logger).to be_kind_of Logger
+  end
+
+  it "sets sql migrators" do
+    repo = subject[:baz]
+    expect(repo.migrator).not_to be_nil
+    expect(repo.migrator.path).to eq migrate
+  end
+
+  after do
+    `rm #{ migrate } -r -f`
+    `rm #{ tmp } -r -f`
+  end
+
+end # specification

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+begin
+  require "hexx-suit"
+  Hexx::Suit.load_metrics_for(self)
+rescue LoadError
+  require "hexx-rspec"
+  Hexx::RSpec.load_metrics_for(self)
+end
+
+# Loads the code under test
+require "hexx-storage"

data/spec/tests/storage/base_spec.rb

@@ -0,0 +1,178 @@
+# encoding: utf-8
+
+describe Hexx::Storage::Base do
+
+  # Stub builder to isolate tests
+  let(:settings) { double :settings                              }
+  let(:storage)  { double :storage, settings: settings           }
+  let(:builder)  { Hexx::Storage::Repositories                   }
+  before         { allow(builder).to receive(:build) { storage } }
+
+  shared_context "setup" do
+    before do
+      subject.root  = File.expand_path "..", __FILE__
+      subject.setup foo: { adapter: :memory }, bar: { adapter: :memory }
+    end
+  end
+
+  describe "#root" do
+
+    it "returns nil by default" do
+      expect(subject.root).to be_nil
+    end
+
+  end # describe #root
+
+  describe "#root=" do
+
+    let(:folder) { File.expand_path "..", __FILE__ }
+    let(:wrong)  { File.join folder, "wrong" }
+
+    it "sets the #root if a folder exists" do
+      expect { subject.root = folder }.to change { subject.root }.to folder
+    end
+
+    it "doesn't set the #root if a folder is absent" do
+      expect { subject.root = wrong }.not_to change { subject.root }
+    end
+
+  end # describe #root=
+
+  describe "#setup" do
+
+    let(:source) do
+      { "foo" => { "adapter" => "memory", "uri" => "bar", "log" => "baz" } }
+    end
+
+    context "when #root hasn't been set" do
+
+      it "raises NotImplementedError" do
+        expect { subject.setup(source) }.to raise_error NotImplementedError
+      end
+
+    end # context
+
+    context "when #root has been set" do
+
+      let(:root) { File.expand_path "..", __FILE__ }
+      before     { subject.root = root             }
+
+      it "builds repo storages" do
+        expect(builder)
+          .to receive(:build)
+          .with(root: root, adapter: "memory", uri: "bar", log: "baz")
+        subject.setup source
+      end
+
+      it "sets storages" do
+        expect { subject.setup source }.to change { subject[:foo] }.to storage
+      end
+
+    end # context
+
+  end # describe #setup
+
+  describe "#load" do
+
+    let(:file) { Tempfile.new %w(foo .yml) }
+    let(:path) { file.path                 }
+    let(:name) { File.basename path        }
+
+    before do
+      file.write "---\ntest:\n  foo:\n    adapter: foo\n    uri: bar\n"
+      file.read
+    end
+
+    context "when #root hasn't been set" do
+
+      it "raises NotImplementedError" do
+        expect { subject.load(name, env: "test") }
+          .to raise_error NotImplementedError
+      end
+
+    end # context
+
+    context "when #root has been set" do
+
+      let(:root) { File.dirname path   }
+      before     { subject.root = root }
+
+      it "sets storages from file" do
+        expect(subject)
+          .to receive(:setup)
+          .with("foo" => { "adapter" => "foo", "uri" => "bar" })
+        subject.load name, env: "test"
+      end
+
+    end # context
+
+  end # describe #load
+
+  describe "#settings" do
+
+    context "before the #setup" do
+
+      it "raises NotImplementedError" do
+        expect { subject.settings }.to raise_error NotImplementedError
+      end
+
+    end # context
+
+    context "after the #setup" do
+
+      include_context "setup"
+
+      it "returns hash of repositories' settings" do
+        expect(subject.settings).to eq(foo: settings, bar: settings)
+      end
+
+    end # context
+
+  end # describe #settings
+
+  describe "#[]" do
+
+    context "by default" do
+
+      it "returns nil" do
+        expect(subject[:foo]).to be_nil
+      end
+
+    end # context
+
+    context "after setup" do
+
+      include_context "setup"
+      let(:repo_storage_class) { Hexx::Storage::Repositories::Memory }
+
+      it "returns the repository settings storage" do
+        expect(subject[:foo]).to eq storage
+      end
+
+    end # context
+
+  end # describe #[]
+
+  describe "#keys" do
+
+    context "by default" do
+
+      it "returns []" do
+        expect(subject.keys).to eq []
+      end
+
+    end # context
+
+    context "after setup" do
+
+      include_context "setup"
+
+      it "returns names of repositories" do
+        expect(subject.keys).to match_array %i(foo bar)
+      end
+
+    end # context
+
+  end # describe #keys
+
+end # describe Hexx::Storage::Base

data/spec/tests/storage/patches_spec.rb

@@ -0,0 +1,202 @@
+# encoding: utf-8
+
+require "tempfile"
+
+describe Hexx::Storage::Patches do
+  using described_class
+
+  describe "for Hash" do
+
+    describe "#normalize" do
+
+      let(:source) { { "foo" => "bar", 1 => "qux" } }
+      let(:target) { { foo: "bar", :"1" => "qux" } }
+
+      it "normalizes a hash" do
+        expect(source.normalize).to eq target
+      end
+
+    end # describe #normalize
+
+    describe "#sub" do
+
+      let(:source) { { "foo" => { "bar" => "baz" }, "bar" => "qux" } }
+
+      context "when a value is a hash" do
+
+        subject { source.sub :foo }
+
+        it "returns the value" do
+          expect(subject).to eq("bar" => "baz")
+        end
+
+      end # context
+
+      context "when a value is not a hash" do
+
+        subject { source.sub :bar }
+
+        it "returns the {}" do
+          expect(subject).to eq({})
+        end
+
+      end # context
+
+      context "when a key is absent" do
+
+        subject { source.sub :baz }
+
+        it "returns the {}" do
+          expect(subject).to eq({})
+        end
+
+      end # context
+
+    end # describe #sub
+
+    describe "#wrap" do
+
+      let(:source) { { foo: %w(a b c), bar: %w(c d) } }
+
+      context "with a block" do
+
+        subject      { source.wrap(&:count) }
+        let(:target) { { foo: 3, bar: 2 }   }
+
+        it "sends values to the block" do
+          expect(subject).to eq target
+        end
+
+      end # context
+
+      context "without a block" do
+
+        subject { source.wrap }
+
+        it "returns a copy of its own" do
+          expect(subject).to eq source
+          expect { subject.freeze }.not_to change { source }
+        end
+
+      end # context
+
+    end # describe #wrap
+
+  end # describe Hash
+
+  describe "for Array" do
+
+    describe "#to_path" do
+
+      let(:source) { ["foo", nil, "/bar/", "baz"] }
+      let(:target) { "foo/bar/baz" }
+
+      it "converts array to filepath" do
+        expect(source.to_path).to eq target
+      end
+
+      it "converts empty array to empty string" do
+        expect([].to_path).to eq ""
+      end
+
+    end # describe #to_path
+
+  end # describe Array
+
+  describe "for String" do
+
+    describe "#from_yaml" do
+
+      context "when the string contains valid yml" do
+
+        let(:source) { "---\nfoo:\n  bar: :baz\n"     }
+        let(:target) { { "foo" => { "bar" => :baz } } }
+
+        subject { source.from_yaml }
+
+        it "converts it to hash" do
+          expect(subject).to eq target
+        end
+
+      end # context
+
+      context "when the string contains invalid yml" do
+
+        subject { "wrong".from_yaml }
+
+        it "returns the {}" do
+          expect(subject).to eq({})
+        end
+
+      end # context
+
+      context "when the string is empty" do
+
+        subject { "".from_yaml }
+
+        it "returns the {}" do
+          expect(subject).to eq({})
+        end
+
+      end # context
+
+    end # describe #from_yaml
+
+    describe "#from_file" do
+
+      context "when the file exists" do
+
+        let(:file)   { Tempfile.create "foo" }
+        let(:source) { file.path             }
+        before       { file.write "foobar"   }
+        let(:target) { file.read             }
+
+        subject { source.from_file }
+
+        it "returns its content" do
+          expect(subject).to eq target
+        end
+
+      end # context
+
+      context "when the file is absent" do
+
+        subject { "".from_file }
+
+        it "returns the empty string" do
+          expect(subject).to eq ""
+        end
+
+      end # context
+
+    end # describe #from_file
+
+    describe "#to_folder" do
+
+      context "when a folder exists" do
+
+        let(:source) { File.expand_path("..", __FILE__) }
+        subject      { source.to_folder                 }
+
+        it "returns a copy of its own if the folder exist" do
+          expect(subject).to eq source
+          expect { subject.freeze }.not_to change { source }
+        end
+
+      end # context
+
+      context "when a folder is absent" do
+
+        subject { ",,".to_folder }
+
+        it "returns nil if the folder is absent" do
+          expect(subject).to be_nil
+        end
+
+      end # context
+
+    end # describe #to_folder
+
+  end # describe String
+
+end # describe Hexx::Storage::Patches