cass_schema 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ed62cce9c48b24a103e72a5ac83df927bee4986a
+  data.tar.gz: 855847953f7f9c54933ab532b7524d81b80aac40
+SHA512:
+  metadata.gz: 90961f405aca7ae569903d92368e5f0fd1a36eb123852644734974956d8ea64d2a75e5b73e9064e4a5797e1ae71f6eda892fe3cd2084bd7745e660cf8f22bf04
+  data.tar.gz: 5cad1a2a5eff5824ce8817ca336ccc79e8fdcfc45121e9f99f4f30d6d9e92b0f27b7df20eef12ed850ea349307fabfa18da8190ac96a5c0ed1d5bc0d1eab4622

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cass_migrations.gemspec
+gemspec
+
+group :development, :test do
+  gem "pry"
+  gem "awesome_print"
+  gem 'm', :git => 'git@github.com:ANorwell/m.git', :branch => 'minitest_5'
+end
+
+group :test do
+  gem 'minitest_should', :git => 'git@github.com:citrus/minitest_should.git'
+  gem "mocha"
+end
+
+gem 'cassandra-driver', :git => 'git@github.com:datastax/ruby-driver.git', :tag => 'v2.0.1'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Datto
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,127 @@
+# CassSchema
+
+A gem for managing multiple cassandra schemas across multiple clusters. CassSchema supports loading a table schema from scratch, as well as running a migration to apply a change to the schema. Unlike some other database migration tools, there is no stored state about which migrations have and have not been run -- a migration is simply a CQL statement to be run against the database.
+
+CassSchema operations apply to multiple 'datastores'. A datastore is a cluster, keyspace pair, so there may be multiple schemas for a single cluster, but only a single schema for a given cluster plus keyspace.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cass_schema', github: 'backupify/cass_schema'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cass_schema
+
+## Usage
+
+Before usage, CassSchema must be initialized with a set of datastore objects, as well as a base directory where the schema definitions live:
+
+```ruby
+CassSchema::Runner.initialize(
+  datastores: CassSchema::YamlHelper.datastores('my/path/to/config.yml'),
+  schema_base_path: 'my/path/to/schema/root')
+```
+
+Here the datastores are a list of `CassSchema::DataStore` objects. These may be build manually, or loaded from a yaml file using the `CassSchema::YamlHelper`. CassSchema is intentionally agnostic about the source of these datastores.
+
+The schema_base_path is a directory where the schema definitions and migrations live. The structure of this directory should be:
+```
+<schema_base_path>/<datastore_name>/schema.cql
+<schema_base_path>/<datastore_name>/migrations/<migration1>.cql
+<schema_base_path>/<datastore_name>/migrations/<migration2>.cql
+...
+
+```
+
+The contents of each cql file should be a list of CQL statements. Comments starting with '#' are supported, and each statement should be separated by two new lines.
+
+schema.cql and each migration should be maintained by hand. It is recommended that schema.cql contain a complete list of CQL statements for the entire, up-to-date schema.
+
+An example yml config and datastore schema definition are in the `test/fixtures` directory.
+
+### Rake tasks
+
+The file `lib/cass_schema/tasks/schema.rake` defines several rake tasks for schema management. In a Rails project, these tasks are loaded when cass_schema is first loaded.
+
+* `rake cass:schema:create_all` - create all schemas
+* `rake cass:schema:drop_all` - drop all schemas
+* `rake cass:schema:create[datastore]` - create the schema for the datastore named 'datastore'
+* `rake cass:schema:drop[datastore]` - drop the schema for the datastore named 'datastore'
+* `rake cass:schema:migrate[datastore, migration]` - run the migration 'migration' for the datastore 'datastore'
+
+### Ruby Library Usage
+
+To create all datastore schemas:
+
+```
+CassSchema::Runner.create_all
+```
+
+To create a particular datastore schemas:
+
+```
+CassSchema::Runner.create('datastore')
+```
+
+To drop all datastore schemas:
+
+```
+CassSchema::Runner.drop_all
+```
+
+To drop a particular datastore schemas:
+
+```
+CassSchema::Runner.drop('datastore')
+```
+
+To run a particular migration for a particular datastore:
+
+```
+CassSchema::Runner.migrate('datastore', 'migration')
+```
+
+Here the migration file 'migration.cql' should exist.
+
+### Integration with other libraries
+
+While `CassSchema::YamlLoader` provides ease of use, it is not required: the runner can be instantiated
+with any list of `CassSchema::Datastore` objects. Here is an example manual set up:
+
+```ruby
+cluster = CassSchema::Cluster.build(hosts: ['127.0.0.1'], port: 9242)
+replication = "{ 'class' : 'SimpleStrategy', 'replication_factor' : 1 }"
+datastores = [
+  CassSchema::Datastore.build('test_datastore', cluster: cluster, keyspace: 'test_keyspace', replication: replication),
+  CassSchema::Datastore.build('test_datastore2', cluster: cluster, keyspace: 'test_keyspace2', replication: replication),
+]
+Runner.setup(datastores: datastores, schema_base_path: 'my/base/path')
+```
+
+This allows CassSchema to be integrated into other configuration schemes more easily.
+
+Additionally, the global `CassSchema::Runner` object need not be used: An instance of `CassSchema::Runner` can be
+constructed and used in the same manner as the global object:
+
+```ruby
+# Accepts the same arguments as Runner#setup
+runner = Runner.new(datastores: datastores, schema_base_path: 'my/base/path')
+runner.create_all
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/backupify/cass_schema/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,20 @@
+require "bundler/gem_tasks"
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.libs.push 'test'
+end
+
+task :setup do
+  require 'bundler/setup'
+  Bundler.require(:default, :development)
+end
+
+
+task :console => [:setup] do
+  Pry.start
+end
+
+task default: :test

data/cass_schema.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cass_schema/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cass_schema"
+  spec.version       = CassSchema::VERSION
+  spec.authors       = ["Arron Norwell"]
+  spec.email         = ["anorwell@gmail.com"]
+  spec.summary       = %q{Manage Cassandra Schemas for multiple conceptual datastores.}
+  spec.description   = %q{A gem for managing the schema multiple Cassandra instances}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency 'cassandra-driver'
+  spec.add_dependency "activesupport"
+end

data/lib/cass_schema/cluster.rb

@@ -0,0 +1,17 @@
+require 'cassandra'
+
+module CassSchema
+  # A struct representing a Cassandra cluster.
+  # @param [Cassandra::Cluster] connection to the cassandra cluster to be used.
+  Cluster = Struct.new(:connection) do
+    def self.build(hash)
+      l = hash.with_indifferent_access
+
+      if l[:hosts]
+        l[:connection] ||= Cassandra.cluster(hosts: l[:hosts], port: l[:port])
+      end
+
+      new(l[:connection])
+    end
+  end if !defined?(Cluster)
+end

data/lib/cass_schema/datastore.rb

@@ -0,0 +1,109 @@
+require_relative 'errors'
+require_relative 'statement_loader'
+require_relative 'cluster'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/object'
+
+module CassSchema
+  # A struct representing a datastore, composed of the following fields:
+  # @param [String] name of the datastore
+  # @param [CassSchema::Cluster] A list of hosts and a port representing the cluster.
+  # @param [String] keyspace
+  # @param [String] A string defining the options with which the keyspace should be created, e.g.:
+  # "{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }"
+  # @param [String] The name of the schema directory within the cass_schema directory, typically the same as the name.
+  # @param [String] Optional base directory to find the schema and migration files.
+  # statements are separated by two new lines, and a statement cannot have two newlines inside of it
+  # comments start with '#'
+  DataStore = Struct.new(:name, :cluster, :keyspace, :replication, :schema, :schema_base_path) do
+
+    attr_reader :logger
+
+    # Creates a datastore object from a hash containing the required keys
+    # @param [String] name of the data store
+    # @option [CassSchema::Cluster] :cluster
+    # @option [String] :schema, defines the schema directory used. Sefaults to the name if not given.
+    # @option [String] :keyspace
+    # @option [String] :replication
+    def self.build(name, hash)
+      l = hash.with_indifferent_access
+      schema = l[:schema] || name
+      new(name, l[:cluster], l[:keyspace], l[:replication], schema, l[:schema_base_path])
+    end
+
+    # Creates the datastore
+    def create
+      run_statement(create_keyspace, general_client)
+      create_statements.each { |statement| run_statement(statement, client) }
+    end
+
+    # Drops the datastore
+    def drop
+      run_statement(drop_keyspace, general_client)
+    end
+
+    # Runs a given migration for this datastore
+    # @param migration_name [String] the name of the migration
+    def migrate(migration_name)
+      migration_statements(migration_name).each { |statement| run_statement(statement, client) }
+    end
+
+    # A Cassava client connected to the cluster and keyspace with which this datastore is associated
+    # @return [Cassandra::Session]
+    def client
+      @client ||= cluster.connection.connect(keyspace)
+    end
+
+    # A Cassava client connected to the cluster with which this datastore is associated
+    # @return [Cassandra::Session]
+    def general_client
+      @general_client ||= cluster.connection.connect
+    end
+
+    # Internal method used by Runner to pass state into the datastore
+    def _setup(options = {})
+      self.schema_base_path ||= options[:schema_base_path]
+      @logger = options[:logger]
+    end
+
+    def schema_path
+      File.join(schema_base_path, schema, 'schema.cql')
+    end
+
+    def schema_base_path
+      self[:schema_base_path]
+    end
+
+    private
+
+    def run_statement(statement, client)
+      log("CassSchema: #{statement}")
+      client.execute(statement)
+    rescue Cassandra::Errors::ConfigurationError
+      # Special case if we cannot create/drop the keyspace, do nothing
+    rescue => e
+      log(e, :error)
+      raise SchemaError.create(e, statement)
+    end
+
+    def create_statements
+      StatementLoader.statements(schema_path)
+    end
+
+    def migration_statements(migration_name)
+      StatementLoader.statements(schema_base_path, schema, 'migrations', "#{migration_name}.cql")
+    end
+
+    def create_keyspace
+      "CREATE KEYSPACE #{keyspace} with replication = #{replication}"
+    end
+
+    def drop_keyspace
+      "DROP KEYSPACE #{keyspace}"
+    end
+
+    def log(msg, level = :info)
+      logger.try { |l| l.send(level, msg) }
+    end
+  end if !defined?(DataStore)
+end

data/lib/cass_schema/errors.rb

@@ -0,0 +1,7 @@
+module CassSchema
+  class SchemaError < StandardError
+    def self.create(cause, statement = nil)
+      new("Error #{cause} when running statement: #{statement}")
+    end
+  end
+end

data/lib/cass_schema/runner.rb

@@ -0,0 +1,87 @@
+module CassSchema
+  class Runner
+
+    class DropCommandsNotAllowed < StandardError
+      def initialize(*_)
+        super('Drop commands have been disabled by the :disallow_drops option')
+      end
+    end
+
+    attr_reader :datastores, :schema_base_path, :logger, :cluster_builder, :disallow_drops
+
+    # Create a new Runner
+    # @option options [Array<CassSchema::Datastore>] :datastores - The list of datastore objects for which schemas
+    #    will be managed.
+    # @option options [String] :schema_bath_path - The directory where schema definitions live. In a rails env,
+    #   this defaults to <rails root>/cass_schema.
+    # @option options [#info|#error] :logger optional logger to use when creating schemas
+    # @option options [Boolean] :disallow_drops Defaults to false. If set to true,
+    # drop commands will raise an exception instead of executing the command.
+    def initialize(options = {})
+      options[:schema_base_path] ||= defined?(::Rails) ? File.join(::Rails.root, 'cass_schema') : nil
+
+      @datastores = options[:datastores]
+      @schema_base_path = options[:schema_base_path]
+      @logger = options[:logger]
+      @disallow_drops = options[:disallow_drops]
+
+      raise ":datastores is a required argument!" unless @datastores
+
+      @datastores.each { |ds| ds._setup(options) }
+    end
+
+    # Create all schemas for all datastores
+    def create_all
+      datastores.each { |d| d.create }
+    end
+
+    # Drop all schemas for all datastores
+    def drop_all
+      raise DropCommandsNotAllowed if disallow_drops
+      datastores.each { |d| d.drop }
+    end
+
+    # Create the schema for a particular datastore
+    # @param [String] datastore_name
+    def create(datastore_name)
+      datastore_lookup(datastore_name).create
+    end
+
+    # Drop the schema for a particular datastore
+    # @param [String] datastore_name
+    def drop(datastore_name)
+      raise DropCommandsNotAllowed if disallow_drops
+      datastore_lookup(datastore_name).drop
+    end
+
+    # Run a particular named migration for a datastore
+    # @param [String] datastore_name
+    # @param [String] migration_name
+    def migrate(datastore_name, migration_name)
+      datastore_lookup(datastore_name).migrate(migration_name)
+    end
+
+    # Find a datastore based on the datastore name
+    # @param datastore_name [String|Symbol] The datastore name
+    # @return [CassSchema::Datastore]
+    def datastore_lookup(datastore_name)
+      @datastore_lookup ||= Hash[datastores.map { |ds| [ds.name, ds] }]
+      @datastore_lookup[datastore_name.to_s] || (raise ArgumentError.new("CassSchema datastore #{datastore_name} not found"))
+    end
+
+    # The class methods for Runner are the same as the instance methods, which delegate to a singleton. To set up the
+    # singleton, call Runner#setup.
+    class << self
+      # (see Runner#initialize)
+      def setup(options = {})
+        @runner = Runner.new(options)
+      end
+
+      (Runner.instance_methods - Object.instance_methods).each do |method|
+        define_method(method) do |*args|
+          @runner.send(method, *args)
+        end
+      end
+    end
+  end
+end

data/lib/cass_schema/statement_loader.rb

@@ -0,0 +1,24 @@
+module CassSchema
+  class StatementLoader
+    class << self
+      def statements(*path_parts)
+        file_path = File.join(path_parts)
+        file = File.open(file_path).read
+
+        # Parse the individual CQL statements as a list from the file. To do so:
+        # - assume statements are separated by two new lines
+        # - strip comments and empty lines from each statement
+        # - remove statements that are empty
+        statements = file.split(/\n{2,}/).map do |statement|
+          statement
+            .split(/\n/)
+            .select { |l| l !~ /^\s*#/ }
+            .select { |l| l !~ /^\s*$/ }
+            .join("\n")
+        end
+
+        statements.select { |s| s.length > 0 }
+      end
+    end
+  end
+end

data/lib/cass_schema/tasks/schema.rake

@@ -0,0 +1,35 @@
+require 'rake'
+
+namespace :cass do
+  namespace :schema do
+
+    desc "Create the cassandra schema for all datastores"
+    task :create_all, [:datastore] => :environment do |t, args|
+      CassSchema::Runner.create_all
+    end
+
+    desc "Drop the cassandra schema for all datastores"
+    task :drop_all, [:datastore] => :environment do |t, args|
+      CassSchema::Runner.drop_all
+    end
+
+    desc "Create the cassandra schema for the specified datastore"
+    task :create, [:datastore] => :environment do |t, args|
+      raise ArgumentError.new('datastore argument required') unless args[:datastore]
+      CassSchema::Runner.create(args[:datastore])
+    end
+
+    desc "Drop the cassandra schema for the specified datastore"
+    task :drop, [:datastore] => :environment do |t, args|
+      raise ArgumentError.new('datastore argument required') unless args[:datastore]
+      CassSchema::Runner.drop(args[:datastore])
+    end
+
+    desc "Run the specified cassandra schema migration for the specified datastore"
+    task :migrate, [:datastore, :migration] => :environment do |t, args|
+      raise ArgumentError.new('datastore argument required') unless args[:datastore]
+      raise ArgumentError.new('migration argument required') unless args[:migration]
+      CassSchema::Runner.migrate(args[:datastore], args[:migration])
+    end
+  end
+end

data/lib/cass_schema/version.rb

@@ -0,0 +1,3 @@
+module CassSchema
+  VERSION = "0.3.1"
+end

data/lib/cass_schema/yaml_helper.rb

@@ -0,0 +1,14 @@
+require_relative 'datastore'
+require 'yaml'
+
+module CassSchema
+  class YamlHelper
+    def self.datastores(config_file)
+      config = YAML.load(File.read(config_file))
+      config['datastores'].map do |name, ds_config|
+        ds_config[:cluster] = Cluster.build(ds_config)
+        DataStore.build(name, ds_config)
+      end
+    end
+  end
+end

data/lib/cass_schema.rb

@@ -0,0 +1,18 @@
+require 'cass_schema/version'
+require 'cass_schema/runner'
+require 'cass_schema/datastore'
+require 'cass_schema/yaml_helper'
+
+module CassSchema; end
+
+if defined?(::Rails)
+  module CassSchema
+    module Rails
+      class Railtie < ::Rails::Railtie
+        rake_tasks do
+          load "cass_schema/tasks/schema.rake"
+        end
+      end
+    end
+  end
+end

data/test/cass_schema/datastore_test.rb

@@ -0,0 +1,13 @@
+require_relative '../test_helper'
+
+module CassSchema
+  class DataStoreTest < MiniTest::Should::TestCase
+    context '#build' do
+      should 'accept the schema base path as an option' do
+        schema_base_path = File.expand_path(__FILE__, '../')
+        ds = CassSchema::DataStore.build("hello", schema_base_path: schema_base_path)
+        assert_equal File.join(schema_base_path, 'hello', 'schema.cql'), ds.schema_path
+      end
+    end
+  end
+end

data/test/cass_schema/runner_test.rb

@@ -0,0 +1,133 @@
+require_relative '../test_helper'
+
+module CassSchema
+  class RunnerTest < MiniTest::Should::TestCase
+
+    setup do
+      @base_path = "#{File.dirname(__FILE__)}/../fixtures"
+      Runner.setup(datastores: YamlHelper.datastores(File.join(@base_path, 'test_config.yml')),
+                   schema_base_path: @base_path)
+    end
+
+    teardown do
+      Runner.drop_all unless @dont_drop_on_teardown
+    end
+
+    def tables_for_keyspace(keyspace)
+      create_client.execute('SELECT * FROM system.schema_columnfamilies').rows.to_a.select { |t| t["keyspace_name"] == keyspace}
+    end
+
+    def schema_for_table(keyspace, table)
+      create_client.execute('SELECT * FROM system.schema_columns').rows.to_a.select do |t|
+        (t["keyspace_name"] == 'test_keyspace') && (t['columnfamily_name'] == table)
+      end
+    end
+
+    context 'creating a schema' do
+      should 'be able to create a datastore' do
+        Runner.create('test_datastore')
+        tables = tables_for_keyspace('test_keyspace')
+        assert_equal %w(test test2).to_set, tables.map { |t| t['columnfamily_name'] }.to_set
+      end
+
+      should 'raise a SchemaError and not execute subsequent schema commands when a schema contains errors' do
+        assert_raises(SchemaError) { Runner.create('invalid_datastore') }
+      end
+
+      should 'raise a misisng file error if schema for a datastore does not exist' do
+        assert_raises(Errno::ENOENT) { Runner.create('missing_datastore') }
+      end
+
+      should 'raise an error if a datastore does not exist' do
+        assert_raises(ArgumentError) { Runner.create('nonexistent_datastore') }
+      end
+
+      should 'be able to create a schema for which the schema name differs from the datastore name' do
+        datastore = Runner.datastore_lookup('test_datastore')
+        datastore.schema = 'test2'
+        Runner.create('test_datastore')
+        tables = tables_for_keyspace('test_keyspace')
+        assert_equal %w(test_other test_other2).to_set, tables.map { |t| t['columnfamily_name'] }.to_set
+
+        datastore.schema = 'test_datastore'
+      end
+    end
+
+    context 'dropping a schema' do
+      should 'be able to drop a datastore' do
+        Runner.create('test_datastore')
+        Runner.drop('test_datastore')
+        tables = tables_for_keyspace('test_keyspace')
+        assert_equal [], tables.map(&:columnfamily_name)
+      end
+
+      should 'raise an error if a datastore does not exist' do
+        assert_raises(ArgumentError) { Runner.drop('nonexistent_datastore') }
+      end
+    end
+
+    context 'running a migration' do
+      should 'be able to run a migration for a datastore' do
+        Runner.create('test_datastore')
+        Runner.migrate('test_datastore', 'migration')
+        schema = schema_for_table('test_datastore', 'test')
+
+        column = schema.find { |col| col['column_name'] == 'new_column'}
+        assert column
+        assert_equal 'org.apache.cassandra.db.marshal.Int32Type', column['validator']
+      end
+
+      should 'raise an error if a datastore does not exist' do
+        assert_raises(ArgumentError) { Runner.create('nonexistent_datastore') }
+      end
+    end
+
+    context 'custom setup' do
+      setup do
+        connection = Cassandra.cluster(hosts: %w(127.0.0.1), port: 9242)
+        cluster = Cluster.build(connection: connection)
+        datastores = [DataStore.build('test_datastore',
+                                      cluster: cluster,
+                                      keyspace: 'test_keyspace',
+                                      replication: "{ 'class' : 'SimpleStrategy', 'replication_factor' : 1 }")]
+        @runner = Runner.new(datastores: datastores, schema_base_path: @base_path )
+      end
+
+      should 'be able to create a datastore' do
+        @runner.create('test_datastore')
+        tables = tables_for_keyspace('test_keyspace')
+        assert_equal %w(test test2).to_set, tables.map { |t| t['columnfamily_name'] }.to_set
+      end
+
+      should 'be able to run a migration' do
+        @runner.create('test_datastore')
+        @runner.migrate('test_datastore', 'migration')
+        schema = schema_for_table('test_datastore', 'test')
+
+        column = schema.find { |col| col['column_name'] == 'new_column'}
+        assert column
+        assert_equal 'org.apache.cassandra.db.marshal.Int32Type', column['validator']
+      end
+    end
+
+    context 'disallowing drops' do
+      setup do
+        Runner.setup(datastores: YamlHelper.datastores(File.join(@base_path, 'test_config.yml')),
+                     schema_base_path: @base_path,
+                     disallow_drops: true
+                    )
+
+        @dont_drop_on_teardown = true
+
+      end
+
+      should 'disallow drop_all if :disallow_drops is set' do
+        assert_raises(CassSchema::Runner::DropCommandsNotAllowed) { Runner.drop_all }
+      end
+
+      should 'disallow drop if :disallow_drops is set' do
+        assert_raises(CassSchema::Runner::DropCommandsNotAllowed) { Runner.drop('test_keyspace') }
+      end
+    end
+  end
+end

data/test/fixtures/invalid_datastore/schema.cql

@@ -0,0 +1,11 @@
+CREATE TABLE test(
+  id text,
+  a text,
+  b text,
+  PRIMARY KEY(id, a))
+
+
+CREATE TABLE test(
+  syntax error,
+  b text,
+  PRIMARY KEY(id, a))

data/test/fixtures/test2/schema.cql

@@ -0,0 +1,12 @@
+CREATE TABLE test_other(
+  id text,
+  a text,
+  b text,
+  PRIMARY KEY(id, a))
+
+# Comment
+CREATE TABLE test_other2(
+  id text,
+  x text,
+  y text,
+  PRIMARY KEY(id, x))

data/test/fixtures/test_config.yml

@@ -0,0 +1,16 @@
+datastores:
+  test_datastore:
+    hosts: 127.0.0.1
+    port: 9242
+    keyspace: test_keyspace
+    replication: "{ 'class' : 'SimpleStrategy', 'replication_factor' : 1 }"
+  invalid_datastore:
+    hosts: 127.0.0.1
+    port: 9242
+    keyspace: test_keyspace_invalid
+    replication: "{ 'class' : 'SimpleStrategy', 'replication_factor' : 1 }"
+  missing_datastore:
+    hosts: 127.0.0.1
+    port: 9242
+    keyspace: test_keyspace_invalid
+    replication: "{ 'class' : 'SimpleStrategy', 'replication_factor' : 1 }"

data/test/fixtures/test_datastore/migrations/migration.cql

@@ -0,0 +1 @@
+ALTER TABLE test ADD new_column int;

data/test/fixtures/test_datastore/schema.cql

@@ -0,0 +1,14 @@
+# CREATE KEYSPACE test_keyspace with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 }
+
+CREATE TABLE test(
+  id text,
+  a text,
+  b text,
+  PRIMARY KEY(id, a))
+
+# Comment
+CREATE TABLE test2(
+  id text,
+  x text,
+  y text,
+  PRIMARY KEY(id, x))

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'pry'
+require 'minitest/autorun'
+require 'minitest/should'
+
+
+require 'cass_schema'
+
+class Minitest::Should::TestCase
+  def self.xshould(*args)
+    puts "Disabled test: #{args}"
+  end
+end
+
+def create_client
+  c = Cassandra.cluster(port: 9242)
+  c.connect
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: cass_schema
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Arron Norwell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: cassandra-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A gem for managing the schema multiple Cassandra instances
+email:
+- anorwell@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cass_schema.gemspec
+- lib/cass_schema.rb
+- lib/cass_schema/cluster.rb
+- lib/cass_schema/datastore.rb
+- lib/cass_schema/errors.rb
+- lib/cass_schema/runner.rb
+- lib/cass_schema/statement_loader.rb
+- lib/cass_schema/tasks/schema.rake
+- lib/cass_schema/version.rb
+- lib/cass_schema/yaml_helper.rb
+- test/cass_schema/datastore_test.rb
+- test/cass_schema/runner_test.rb
+- test/fixtures/invalid_datastore/schema.cql
+- test/fixtures/test2/schema.cql
+- test/fixtures/test_config.yml
+- test/fixtures/test_datastore/migrations/migration.cql
+- test/fixtures/test_datastore/schema.cql
+- test/test_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Manage Cassandra Schemas for multiple conceptual datastores.
+test_files:
+- test/cass_schema/datastore_test.rb
+- test/cass_schema/runner_test.rb
+- test/fixtures/invalid_datastore/schema.cql
+- test/fixtures/test2/schema.cql
+- test/fixtures/test_config.yml
+- test/fixtures/test_datastore/migrations/migration.cql
+- test/fixtures/test_datastore/schema.cql
+- test/test_helper.rb