rom-cassandra 0.0.1

data/spec/unit/gateway_spec.rb

@@ -0,0 +1,140 @@
+# encoding: utf-8
+
+describe ROM::Cassandra::Gateway do
+
+  let(:gateway) { described_class.new(uri) }
+  let(:uri)     { { hosts: ["127.0.0.1"], port: 9042 } }
+
+  describe ".new" do
+    after { described_class.new("127.0.0.2", port: 9042) }
+
+    let(:session_class) { ROM::Cassandra::Session }
+
+    it "creates the session with uri" do
+      allow(session_class).to receive(:new)
+      expect(session_class).to receive(:new).with("127.0.0.2", port: 9042)
+    end
+  end # describe .new
+
+  describe "#options" do
+    subject { gateway.options }
+
+    it "returns a uri" do
+      expect(subject).to eql(uri)
+    end
+  end # describe #options
+
+  describe "#session" do
+    subject { gateway.session }
+
+    it "is a session" do
+      expect(subject).to be_instance_of ROM::Cassandra::Session
+    end
+
+    it "has a proper uri" do
+      expect(subject.uri).to eql uri
+    end
+  end # describe #session
+
+  describe "#[]" do
+    subject { gateway["foo.bar"] }
+
+    context "by default" do
+      it { is_expected.to be_nil }
+    end
+
+    context "registered dataset" do
+      before { gateway.dataset "foo.bar" }
+
+      it { is_expected.to be_instance_of ROM::Cassandra::Dataset }
+    end
+  end # describe #[]
+
+  describe "#dataset?" do
+    subject { gateway.dataset? "foo.bar" }
+
+    context "by default" do
+      it { is_expected.to eql false }
+    end
+
+    context "registered dataset" do
+      before { gateway.dataset "foo.bar" }
+
+      it { is_expected.to eql true }
+    end
+  end # describe #dataset?
+
+  describe "#dataset" do
+    subject { gateway.dataset(name) }
+
+    context "with valid name" do
+      let(:name) { :"foo.bar" }
+
+      it "registers the dataset for given table" do
+        subject
+        dataset = gateway["foo.bar"]
+
+        expect(dataset.session).to eql(gateway.session)
+        expect(dataset.keyspace).to eql :foo
+        expect(dataset.table).to eql :bar
+      end
+    end
+
+    context "with a string name" do
+      let(:name) { "foo.bar" }
+
+      it "registers the dataset for given table" do
+        expect { subject }.to change { gateway[:"foo.bar"] }
+      end
+    end
+
+    context "with invalid name" do
+      let(:name) { "foo" }
+
+      it "fails" do
+        expect { subject }.to raise_error do |error|
+          expect(error).to be_kind_of ArgumentError
+          expect(error.message)
+            .to eql "'foo' is not a valid full name of a table. " \
+            "Use format 'keyspace.table' with both keyspace and table parts."
+        end
+      end
+    end
+  end # describe #dataset
+
+  describe "#migrate" do
+    let(:klass)    { ROM::Cassandra::Migrations::Migrator }
+    let(:session)  { gateway.session }
+    let(:migrator) { double :migrator, apply: nil }
+    let(:path)     { double :path }
+    let(:version)  { double :version }
+    let(:logger)   { double :logger }
+
+    before { allow(klass).to receive(:new) { migrator } }
+
+    context "with options" do
+      after { gateway.migrate path: path, version: version, logger: logger }
+
+      it "initializes the migrator" do
+        expect(klass).to receive(:new).with(session, path: path, logger: logger)
+      end
+
+      it "runs the migrator" do
+        expect(migrator).to receive(:apply).with(version: version)
+      end
+    end
+
+    context "without options" do
+      after { gateway.migrate }
+
+      it "initializes the migrator" do
+        expect(klass).to receive(:new).with(session, {})
+      end
+
+      it "runs the migrator" do
+        expect(migrator).to receive(:apply).with({})
+      end
+    end
+  end # describe #migrate
+
+end # describe ROM:Cassandra::Gateway

data/spec/unit/migrations/generator_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require "shared/fake_migrate_folder"
+require "timecop"
+
+describe ROM::Cassandra::Migrations::Generator do
+
+  include_context :fake_migrate_folder, "context"
+
+  let(:name)    { "createFoo" }
+  let(:time)    { Time.utc(2017, "dec", 31, 23, 59, 59) }
+  let(:target)  { "#{path}/db/20171231235959_create_foo.rb" }
+  let(:content) { File.read(target) }
+
+  describe ".call" do
+    subject { described_class.call(name, "#{path}/db") }
+
+    before { Timecop.freeze(time) }
+    after  { Timecop.return }
+
+    it "creates the migration" do
+      subject
+      expect(content).to include "CreateFoo"
+    end
+
+    it "returns the name of the migration" do
+      expect(subject).to eql(target)
+    end
+  end # describe .call
+
+end # describe ROM::Cassandra::Migrations::Generator

data/spec/unit/migrations/logger_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+describe ROM::Cassandra::Migrations::Logger do
+
+  let(:logger) { described_class.new }
+  let(:stdout) { StringIO.new }
+
+  before { $stdout = stdout }
+  after  { $stdout = STDOUT }
+
+  describe ".new" do
+    subject { logger }
+
+    it { is_expected.to be_kind_of ::Logger }
+
+    it "sends messages to $stdout" do
+      expect { subject.info "text" }.to change { stdout.string }.to "text\n"
+    end
+  end # describe .new
+
+end # describe ROM::Cassandra::Migrations::Logger

data/spec/unit/migrations/migration_spec.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+describe ROM::Cassandra::Migrations::Migration do
+
+  let(:migration) { described_class.new session }
+  let(:session)   { double :session, call: nil, freeze: nil }
+
+  describe "#session" do
+    subject { migration.session }
+
+    it { is_expected.to eql session }
+  end # describe #session
+
+  describe "#up" do
+    subject { migration.up }
+
+    it { is_expected.to be_nil }
+  end # describe #up
+
+  describe "#down" do
+    subject { migration.down }
+
+    it { is_expected.to be_nil }
+  end # describe #down
+
+  describe "#call" do
+    subject { migration.call query }
+    let(:query) { double :query, to_s: :foo }
+
+    it "is delegated to #session" do
+      expect(session).to receive(:call).with(:foo)
+      subject
+    end
+  end # describe #call
+
+  describe "#keyspace" do
+    subject { migration.keyspace(:foo) }
+
+    it "starts building query" do
+      query = subject.create.if_not_exists.to_s
+
+      expect(query).to eql "CREATE KEYSPACE IF NOT EXISTS foo;"
+    end
+  end # describe #keyspace
+
+  describe ".inherited" do
+    subject { Class.new described_class }
+
+    it "hides helpers" do
+      expect(subject.private_instance_methods)
+        .to include(:call, :keyspace, :up, :down)
+    end
+
+    it "keeps parent class' helpers unchanged" do
+      expect { subject }.not_to change { described_class.new(session).methods }
+    end
+  end # describe .inherited
+
+end # describe ROM::Cassandra::Migrations::Migration

data/spec/unit/migrations/migrator_spec.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+require "shared/fake_migrate_folder"
+
+describe ROM::Cassandra::Migrations::Migrator do
+
+  include_context :fake_migrate_folder, "context"
+
+  let(:migrator) { described_class.new session, logger: logger, path: path }
+  let(:logger)   { double :logger }
+  let(:session)  { double :session, call: nil }
+
+  describe "#session" do
+    subject { migrator.session }
+
+    it "returns the session by uri" do
+      expect(subject).to eql(session)
+    end
+  end # describe #session
+
+  describe "#logger" do
+    subject { migrator.logger }
+
+    context "when logger is specified" do
+      it { is_expected.to eql logger }
+    end
+
+    context "when logger isn't specified" do
+      let(:migrator) { described_class.new session }
+
+      it { is_expected.to be_kind_of ROM::Cassandra::Migrations::Logger }
+    end
+  end # describe #logger
+
+  describe "#root" do
+    subject { migrator.root }
+
+    context "when path is specified" do
+      it { is_expected.to eql path }
+    end
+
+    context "when path isn't specified" do
+      let(:migrator) { described_class.new session }
+
+      it { is_expected.to eql("db/migrate") }
+    end
+  end # describe #root
+
+  describe "#paths" do
+    subject { migrator.paths }
+
+    it "returns the ordered list of migrations" do
+      expect(subject).to eql(files)
+    end
+  end # describe #paths
+
+  describe "#apply" do
+    before { allow(ROM::Cassandra::Migrations::Runner).to receive(:apply) }
+
+    let(:runner_up)   { ROM::Cassandra::Migrations::RunnerUp }
+    let(:runner_down) { ROM::Cassandra::Migrations::RunnerDown }
+
+    context "without a version" do
+      after { migrator.apply }
+
+      it "applies all migrations in direct order" do
+        files.each do |path|
+          expect(runner_up)
+            .to receive(:apply)
+            .with(session, logger, path)
+            .ordered
+        end
+      end
+
+      it "doesn't rollback migrations" do
+        expect(runner_down).not_to receive(:apply)
+      end
+    end
+
+    context "with the zero version" do
+      after { migrator.apply version: 0 }
+
+      it "rolls back all migrations in reverse order" do
+        files.reverse_each do |path|
+          expect(runner_down)
+            .to receive(:apply)
+            .with(session, logger, path)
+            .ordered
+        end
+      end
+
+      it "doesn't apply migrations" do
+        expect(runner_up).not_to receive(:apply)
+      end
+    end
+
+    context "with a non-zero version" do
+      after { migrator.apply version: 20160101000000 }
+
+      it "applies migrations up to the version in direct order" do
+        files[0..1].each do |path|
+          expect(runner_up)
+            .to receive(:apply)
+            .with(session, logger, path)
+            .ordered
+        end
+      end
+
+      it "rolls back migrations with greater versions in reverse order" do
+        files[2..-1].reverse_each do |path|
+          expect(runner_down)
+            .to receive(:apply)
+            .with(session, logger, path)
+            .ordered
+        end
+      end
+    end
+  end # describe #apply
+
+end # describe ROM::Cassandra::Migrations::Migrator

data/spec/unit/migrations/runner_down_spec.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+describe ROM::Cassandra::Migrations::RunnerDown do
+
+  let(:klass)   { Class.new described_class }
+  let(:runner)  { klass.new session, logger, path }
+  let(:session) { double :session, call: nil }
+  let(:logger)  { double :logger, info: nil }
+  let(:path)    { "foo/20150824103059_add_foo.rb" }
+
+  before do
+    klass.send(:define_method, :require) do |_|
+      AddFoo = Class.new(ROM::Cassandra::Migrations::Migration)
+    end
+    klass.send(:define_method, :select_version) { [{ id: 20150824103059 }] }
+  end
+
+  describe "#migrate?" do
+    subject { runner.migrate? }
+
+    context "when select_version isn't empty" do
+      it { is_expected.to eql true }
+    end
+
+    context "when select_version is empty" do
+      before { klass.send(:define_method, :select_version) { [] } }
+
+      it { is_expected.to eql false }
+    end
+  end # describe #migrate?
+
+  describe "#apply" do
+    after  { runner.apply }
+    before { allow(runner).to receive(:migration) { migration } }
+
+    let(:migration) { double :migration, down: nil }
+
+    it "rolls back migration" do
+      expect(migration).to receive(:down).once
+    end
+  end # describe #apply
+
+  describe "#register" do
+    after { runner.register }
+
+    it "sends the DELETE query to session" do
+      expect(session)
+        .to receive(:call)
+        .with "DELETE FROM rom.migrations WHERE version = '20150824103059';"
+    end
+  end # describe #register
+
+  describe "#log" do
+    after { runner.log }
+
+    it "logs the message" do
+      expect(logger)
+        .to receive(:info)
+        .with "Roll back migration 20150824103059\n"
+    end
+  end # describe #log
+
+  after { Object.send :remove_const, :AddFoo if Object.const_defined? :AddFoo }
+
+end # describe ROM::Cassandra::Migrations::RunnerDown

data/spec/unit/migrations/runner_spec.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+describe ROM::Cassandra::Migrations::Runner do
+
+  let(:klass)   { Class.new described_class }
+  let(:runner)  { klass.new session, logger, path }
+  let(:session) { double :session, call: nil }
+  let(:logger)  { double :logger }
+  let(:path)    { "foo/20150824103059_add_foo.rb" }
+
+  before do
+    klass.send(:define_method, :migrate?) { true }
+    klass.send(:define_method, :require) do |name|
+      AddFoo = Class.new(ROM::Cassandra::Migrations::Migration) if name == path
+      true
+    end
+  end
+
+  describe "#session" do
+    subject { runner.session }
+
+    it { is_expected.to eql session }
+  end # describe #session
+
+  describe "#logger" do
+    subject { runner.logger }
+
+    it { is_expected.to eql logger }
+  end # describe #logger
+
+  describe "#path" do
+    subject { runner.path }
+
+    it { is_expected.to eql path }
+  end # describe #path
+
+  describe "#version" do
+    subject { runner.version }
+
+    context "from valid timestamp" do
+      let(:path) { "foo/12345678901234/20150824103059_add_foo.rb" }
+
+      it { is_expected.to eql 20150824103059 }
+    end
+
+    context "from invalid timestamp" do
+      let(:path) { "foo/2015082410305_add_foo.rb" }
+
+      it "fails" do
+        expect { subject }.to raise_error do |error|
+          expect(error).to be_kind_of NameError
+          expect(error.message)
+            .to eql("invalid version number: 'foo/2015082410305_add_foo.rb'")
+        end
+      end
+    end
+  end # describe #version
+
+  describe "#migration" do
+    subject { runner.migration }
+
+    it "creates migration for #session" do
+      expect(subject).to be_kind_of(AddFoo)
+      expect(subject.session).to eql(session)
+    end
+
+    context "when #migrate? is falsey" do
+      before { klass.send(:define_method, :migrate?) { nil } }
+
+      it { is_expected.to eql nil }
+    end
+  end # describe #migration
+
+  describe "#clear" do
+    subject { runner.clear }
+
+    before { runner }
+  end # describe #clear
+
+  describe "#call" do
+    before do
+      allow(runner).to receive(:apply)
+      allow(runner).to receive(:register)
+      allow(runner).to receive(:log)
+    end
+
+    subject { runner.call }
+
+    it "calls commands in the right order" do
+      expect(runner).to receive(:apply).ordered
+      expect(runner).to receive(:register).ordered
+      expect(runner).to receive(:log).ordered
+      subject
+    end
+
+    context "when #migration isn't set" do
+      before { allow(runner).to receive(:migration) }
+
+      it "skips all commands" do
+        expect(runner).not_to receive(:apply)
+        expect(runner).not_to receive(:register)
+        expect(runner).not_to receive(:log)
+        subject
+      end
+    end
+  end # describe #call
+
+  describe "#select_version" do
+    after { runner.select_version }
+
+    let(:queries) do
+      [
+        "CREATE KEYSPACE IF NOT EXISTS rom WITH REPLICATION =" \
+          " {'class': 'SimpleStrategy', 'replication_factor': 3};",
+        "CREATE TABLE IF NOT EXISTS rom.migrations " \
+          "(version text, PRIMARY KEY (version));",
+        "SELECT * FROM rom.migrations WHERE version = '20150824103059';"
+      ]
+    end
+
+    it "sends requests to Cassandra cluster" do
+      queries.each do |query|
+        expect(session).to receive(:call).with(query).ordered
+      end
+    end
+  end # describe #select_version
+
+  describe ".apply" do
+    let(:runner) { double :runner, call: nil }
+
+    before { allow(described_class).to receive(:new) { runner } }
+    after  { described_class.apply(session, logger, path) }
+
+    it "creates and calls the runner" do
+      expect(described_class).to receive(:new).with(session, logger, path)
+      expect(runner).to receive(:call)
+    end
+  end # describe .apply
+
+  after { Object.send :remove_const, :AddFoo if Object.const_defined? :AddFoo }
+
+end # describe ROM::Cassandra::Migrations::Runner