cassanity 0.4.0 → 0.5.0

data/spec/integration/cassanity/instrumentation/statsd_subscriber_spec.rb

@@ -0,0 +1,58 @@
+require 'helper'
+require 'cassanity/instrumentation/statsd'
+
+describe Cassanity::Instrumentation::StatsdSubscriber do
+  let(:statsd_client) { Statsd.new }
+  let(:socket) { FakeUDPSocket.new }
+
+  let(:client) {
+    Cassanity::Client.new(CassanityServers, {
+      instrumenter: ActiveSupport::Notifications,
+    })
+  }
+
+  let(:keyspace) { client[:cassanity_test] }
+
+  let(:column_family) {
+    keyspace.column_family({
+      name: :apps,
+      schema: {
+        primary_key: :id,
+        columns: {
+          id: :timeuuid,
+          name: :text,
+        },
+      },
+    })
+  }
+
+  before do
+    described_class.client = statsd_client
+    keyspace.recreate
+    column_family.recreate
+    Thread.current[:statsd_socket] = socket
+  end
+
+  after do
+    described_class.client = nil
+    Thread.current[:statsd_socket] = nil
+  end
+
+  it "updates timers when cql calls happen" do
+    # Clear the socket so we don't count the operations required to re-create
+    # the keyspace and column family.
+    socket.clear
+
+    column_family.insert({
+      data: {
+        id: SimpleUUID::UUID.new,
+        name: 'GitHub.com',
+      },
+    })
+
+    socket.recv.first.should match(/cassanity\.cql\:\d+\|ms/)
+    socket.recv.first.should match(/cassanity\.command\.column_family_insert\.cql\:\d+\|ms/)
+    socket.recv.first.should match(/cassanity\.column_family\.apps\.cql\:\d+\|ms/)
+    socket.recv.first.should match(/cassanity\.column_family.apps.column_family_insert.cql\:\d+\|ms/)
+  end
+end

data/spec/integration/cassanity/keyspace_spec.rb

@@ -6,7 +6,7 @@ describe Cassanity::Keyspace do
   let(:self_created_keyspace_name) { 'self_created' }
   let(:column_family_name)         { 'apps' }
 
-  let(:client) { Cassanity::Client.new }
+  let(:client) { Cassanity::Client.new(CassanityServers) }
   let(:driver) { client.driver }
 
   let(:required_arguments) {
@@ -21,41 +21,41 @@ describe Cassanity::Keyspace do
   }
 
   before do
-    client_drop_keyspace(driver, keyspace_name)
-    client_create_keyspace(driver, keyspace_name)
+    driver_drop_keyspace(driver, keyspace_name)
+    driver_create_keyspace(driver, keyspace_name)
   end
 
   after do
-    client_drop_keyspace(driver, keyspace_name)
-    client_drop_keyspace(driver, self_created_keyspace_name)
+    driver_drop_keyspace(driver, keyspace_name)
+    driver_drop_keyspace(driver, self_created_keyspace_name)
   end
 
   it "can create" do
-    client_keyspace?(driver, self_created_keyspace_name).should be_false
+    driver_keyspace?(driver, self_created_keyspace_name).should be_false
     instance = described_class.new(required_arguments.merge({
       name: self_created_keyspace_name,
     }))
     instance.create
-    client_keyspace?(driver, self_created_keyspace_name).should be_true
+    driver_keyspace?(driver, self_created_keyspace_name).should be_true
   end
 
   it "knows if it exists" do
     subject.exists?.should be_true
-    client_drop_keyspace(driver, keyspace_name)
+    driver_drop_keyspace(driver, keyspace_name)
     subject.exists?.should be_false
   end
 
   it "can recreate when not created" do
-    client_drop_keyspace(driver, keyspace_name)
-    client_keyspace?(driver, keyspace_name).should be_false
+    driver_drop_keyspace(driver, keyspace_name)
+    driver_keyspace?(driver, keyspace_name).should be_false
     subject.recreate
-    client_keyspace?(driver, keyspace_name).should be_true
+    driver_keyspace?(driver, keyspace_name).should be_true
   end
 
   it "can recreate when already created" do
-    client_keyspace?(driver, keyspace_name).should be_true
+    driver_keyspace?(driver, keyspace_name).should be_true
     subject.recreate
-    client_keyspace?(driver, keyspace_name).should be_true
+    driver_keyspace?(driver, keyspace_name).should be_true
   end
 
   it "can use" do
@@ -66,14 +66,14 @@ describe Cassanity::Keyspace do
   end
 
   it "can drop" do
-    client_keyspace?(driver, keyspace_name).should be_true
+    driver_keyspace?(driver, keyspace_name).should be_true
     subject.drop
-    client_keyspace?(driver, keyspace_name).should be_false
+    driver_keyspace?(driver, keyspace_name).should be_false
   end
 
   it "knows column families" do
-    client_create_column_family(driver, 'something1')
-    client_create_column_family(driver, 'something2')
+    driver_create_column_family(driver, :something1)
+    driver_create_column_family(driver, :something2)
 
     result = subject.column_families
     result.each do |column_family|
@@ -82,10 +82,10 @@ describe Cassanity::Keyspace do
     end
 
     names = result.map(&:name)
-    names.should include('something1')
-    names.should include('something2')
+    names.should include(:something1)
+    names.should include(:something2)
 
-    client_drop_column_family(driver, 'something1')
-    client_drop_column_family(driver, 'something2')
+    driver_drop_column_family(driver, :something1)
+    driver_drop_column_family(driver, :something2)
   end
 end

data/spec/integration/cassanity/migration_spec.rb

@@ -0,0 +1,157 @@
+require 'helper'
+require 'cassanity/migrator'
+
+describe Cassanity::Migration do
+  let(:client) { Cassanity::Client.new(CassanityServers) }
+  let(:driver) { client.driver }
+  let(:keyspace) { client[:cassanity_test] }
+  let(:migrator) { Cassanity::Migrator.new(keyspace, '/fake') }
+  let(:migration) { Class.new(described_class).new(migrator) }
+
+  before do
+    driver_drop_keyspace(driver, keyspace.name)
+    driver_create_keyspace(driver, keyspace.name)
+  end
+
+  describe "#create_column_family" do
+    before do
+      migration.create_column_family(:users, {
+        primary_key: :id,
+        columns: {
+          id: :timeuuid,
+          name: :text,
+          age: :int,
+        },
+      })
+    end
+
+    it "creates a column family" do
+      keyspace[:users].exists?.should be_true
+    end
+  end
+
+  describe "#drop_column_family" do
+    before do
+      keyspace.column_family(:users, schema: {
+        primary_key: :id,
+        columns: {
+          id: :timeuuid,
+          name: :text,
+          age: :int,
+        },
+      }).create
+
+      migration.drop_column_family :users
+    end
+
+    it "drops column family" do
+      keyspace[:users].exists?.should be_false
+    end
+  end
+
+  describe "#add_column" do
+    before do
+      keyspace.column_family(:users, schema: {
+        primary_key: :id,
+        columns: {
+          id: :timeuuid,
+          name: :text,
+          age: :int,
+        },
+      }).create
+
+      migration.add_column :users, :email, :text
+    end
+
+    it "adds column" do
+      columns = keyspace[:users].columns
+      column = columns.detect { |column| column.name == :email }
+      column.should_not be_nil
+      column.type.should be(:text)
+    end
+  end
+
+  describe "#drop_column" do
+    before do
+      keyspace.column_family(:users, schema: {
+        primary_key: :id,
+        columns: {
+          id: :timeuuid,
+          name: :text,
+          age: :int,
+        },
+      }).create
+
+      migration.drop_column :users, :age
+    end
+
+    it "drops column" do
+      columns = keyspace[:users].columns
+      column = columns.detect { |column| column.name == :age }
+      column.should be_nil
+    end
+  end
+
+  describe "#alter_column_family" do
+    before do
+      keyspace.column_family(:users, schema: {
+        primary_key: :id,
+        columns: {
+          id: :timeuuid,
+          name: :text,
+          age: :int,
+        },
+      }).create
+
+      migration.alter_column_family :users, drop: :age
+    end
+
+    it "alters the column family" do
+      columns = keyspace[:users].columns
+      column = columns.detect { |column| column.name == :age }
+      column.should be_nil
+    end
+  end
+
+  describe "#add_index" do
+    before do
+      keyspace.column_family(:users, schema: {
+        primary_key: :id,
+        columns: {
+          id: :timeuuid,
+          email: :text,
+        },
+      }).create
+
+      migration.add_index :users, :email, name: :users_email_index
+    end
+
+    it "adds index" do
+      meta = driver.schema.column_families['users'].column_metadata
+      index = meta.detect { |c| c.index_name == 'users_email_index' }
+      index.should_not be_nil
+    end
+  end
+
+  describe "#drop_index" do
+    before do
+      column_family = keyspace.column_family(:users, schema: {
+        primary_key: :id,
+        columns: {
+          id: :timeuuid,
+          email: :text,
+        },
+      })
+      column_family.create
+      column_family.create_index(column_name: :email, name: :users_email_index)
+
+      migration.drop_index :users, :users_email_index
+    end
+
+    it "drops index" do
+      meta = driver.schema.column_families['users'].column_metadata
+      index = meta.detect { |c| c.index_name == 'users_email_index' }
+      index.should be_nil
+    end
+  end
+end

data/spec/integration/cassanity/migrator_spec.rb

@@ -0,0 +1,212 @@
+require 'helper'
+require 'cassanity/migrator'
+
+describe Cassanity::Migrator do
+  let(:client) { Cassanity::Client.new(CassanityServers) }
+  let(:driver) { client.driver }
+  let(:keyspace) { client[:cassanity_test] }
+  let(:column_family) { subject.column_family }
+
+  let(:migrations_path) {
+    Pathname(__FILE__).dirname.join('fixtures', 'migrations')
+  }
+
+  let(:log_string) { StringIO.new }
+
+  let(:logger) {
+    logger = Logger.new(log_string)
+    logger.formatter = proc { |_, _, _, msg| "#{msg}\n" }
+    logger
+  }
+
+  subject {
+    described_class.new(keyspace, migrations_path, {
+      logger: logger,
+    })
+  }
+
+  before do
+    driver_drop_keyspace(driver, keyspace.name)
+    driver_create_keyspace(driver, keyspace.name)
+  end
+
+  describe "#migrate" do
+    context "when no migrations have been run" do
+      before do
+        @result = subject.migrate
+      end
+
+      it "runs all migrations" do
+        @result[:performed].size.should be(3)
+      end
+
+      it "stores migrations in column family" do
+        rows = column_family.select
+        rows.size.should be(3)
+
+        version_to_name = {
+          '20130224135000' => 'create_users',
+          '20130225135002' => 'create_apps',
+          '20130226135004' => 'add_username_to_users',
+        }
+
+        rows.each do |row|
+          version_to_name.fetch(row['version']).should eq(row['name'])
+        end
+      end
+
+      it "executes migrations" do
+        keyspace[:users].exists?.should be_true
+        keyspace[:apps].exists?.should be_true
+      end
+    end
+
+    context "when some migrations have been run" do
+      before do
+        subject.migrate_to subject.migrations[1].version
+        @result = subject.migrate
+      end
+
+      it "runs only migrations that need to be" do
+        versions = @result[:performed].map(&:version)
+        versions.should eq([subject.migrations[2].version])
+      end
+    end
+
+    context "when migration has not been run that is older than migrations that have been run" do
+      before do
+        subject.migrated_up subject.migrations[0]
+        subject.migrated_up subject.migrations[2]
+        @result = subject.migrate
+      end
+
+      it "runs migration that has not been run" do
+        versions = @result[:performed].map(&:version)
+        versions.should eq([subject.migrations[1].version])
+      end
+    end
+  end
+
+  describe "#migrate_to" do
+    context "migrating to specific versions" do
+      it "works" do
+        subject.migrate_to(subject.migrations[0].version)
+        subject.performed_migrations.size.should be(1)
+
+        subject.migrate_to(subject.migrations[1].version)
+        subject.performed_migrations.size.should be(2)
+
+        subject.migrate_to(subject.migrations[2].version)
+        subject.performed_migrations.size.should be(3)
+
+        subject.migrate_to(subject.migrations[1].version, :down)
+        subject.performed_migrations.size.should be(2)
+
+        subject.migrate_to(subject.migrations[0].version, :down)
+        subject.performed_migrations.size.should be(1)
+
+        # works with string
+        subject.migrate_to(subject.migrations[0].version - 1, 'down')
+        subject.performed_migrations.size.should be(0)
+      end
+
+      it "raises argument error for invalid direction" do
+        expect {
+          subject.migrate_to(0, 'nooope')
+        }.to raise_error(ArgumentError, ':nooope is not a valid migration direction')
+      end
+
+      it "returns migrations in the order they were performed" do
+        result = subject.migrate_to(subject.migrations[2].version)
+        result[:performed].map(&:version).should eq([
+          subject.migrations[0].version,
+          subject.migrations[1].version,
+          subject.migrations[2].version,
+        ])
+
+        result = subject.migrate_to(0, :down)
+        result[:performed].map(&:version).should eq([
+          subject.migrations[2].version,
+          subject.migrations[1].version,
+          subject.migrations[0].version,
+        ])
+      end
+    end
+  end
+
+  describe "#migrated_up" do
+    it "adds migration to performed migrations" do
+      migration = subject.migrations[0]
+      subject.migrated_up(migration)
+      names = subject.column_family.select.map { |row| row['name'] }
+      names.should include(migration.name)
+    end
+  end
+
+  describe "#migrated_down" do
+    it "removes migration from performed migrations" do
+      migration = subject.migrations[0]
+      subject.column_family.insert(data: {
+        version: migration.version,
+        name: migration.name,
+        migrated_at: Time.now,
+      })
+      subject.migrated_down(migration)
+      names = subject.column_family.select.map { |row| row['name'] }
+      names.should_not include(migration.name)
+    end
+  end
+
+  describe "#migrations" do
+    it "returns all migrations in order from the migrations path" do
+      names = subject.migrations.map(&:name)
+      names.should eq([
+        'create_users',
+        'create_apps',
+        'add_username_to_users',
+      ])
+    end
+  end
+
+  describe "#performed_migrations" do
+    it "returns all performed migrations in order" do
+      subject.migrations.each do |migration|
+        subject.column_family.insert(data: {
+          name: migration.name,
+          version: migration.version,
+          migrated_at: Time.now,
+        })
+      end
+
+      names = subject.performed_migrations.map(&:name)
+      names.should eq([
+        'create_users',
+        'create_apps',
+        'add_username_to_users',
+      ])
+    end
+  end
+
+  describe "#pending_migrations" do
+    it "returns all pending migrations in order" do
+      migration = subject.migrations[0]
+      subject.column_family.insert(data: {
+        name: migration.name,
+        version: migration.version,
+        migrated_at: Time.now,
+      })
+      names = subject.pending_migrations.map(&:name)
+      names.should eq([
+        'create_apps',
+        'add_username_to_users',
+      ])
+    end
+  end
+
+  describe "#log" do
+    it "sends message to logger" do
+      subject.log('just testing')
+      log_string.string.should match("just testing")
+    end
+  end
+end