cassandra_mocks 0.0.8.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e116917fa04c58c22eba8ccc9c08e9787a9ba54d
+  data.tar.gz: a860d89cdece466b8a74af23abb2fd646a6846b5
+SHA512:
+  metadata.gz: e98abfe9fe97cb40bcf5f97829d86673902a5e7d0e97257bf84cbbecc5a3f7a67eb20270c6a10ddfc3affb23e88a6ff3f2ab7e0645dd751163c4e6f2f72b7ed1
+  data.tar.gz: 2898cbb5fd7759b4ddc80d922ee57daf67827887fd7cf24abf1ab638e69bccd28893a79dc88eaecb8dbe55bade37bf8824c2faf3eec4de549e38057fedf41aba

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2014-2015 Thomas RM Rogers
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,17 @@
+# cassandra_mocks
+
+## Copyright
+
+Copyright 2015 Thomas Rogers.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+
+
+
+
+

data/lib/cassandra_mocks/cluster.rb

@@ -0,0 +1,52 @@
+module Cassandra
+  module Mocks
+    class Cluster
+      extend Forwardable
+
+      def_delegator :@keyspaces, :[], :keyspace
+
+      def initialize
+        @keyspaces = {}
+      end
+
+      def connect_async(keyspace = nil)
+        session = Session.new(keyspace, self)
+        Cassandra::Future.value(session)
+      end
+
+      def close_async
+        Cassandra::Future.value(nil)
+      end
+
+      def close
+        close_async.get
+      end
+
+      def connect(keyspace = nil)
+        connect_async(keyspace).get
+      end
+
+      def add_keyspace(name)
+        raise Errors::AlreadyExistsError.new('Cannot create already existing keyspace', 'MockStatement', name, nil) if @keyspaces[name]
+        @keyspaces[name] = Keyspace.new(name)
+      end
+
+      def drop_keyspace(name)
+        @keyspaces.delete(name)
+      end
+
+      def each_keyspace(&block)
+        @keyspaces.values.each(&block)
+      end
+
+      def hosts
+        %w(DummyHost)
+      end
+
+      def find_replicas(*_)
+        []
+      end
+
+    end
+  end
+end

data/lib/cassandra_mocks/keyspace.rb

@@ -0,0 +1,37 @@
+module Cassandra
+  module Mocks
+    class Keyspace < ::Cassandra::Keyspace
+
+      def initialize(name)
+        replication = Replication.new('mock', {})
+        super(name, false, replication, {})
+      end
+
+      def add_table(table_name, primary_key, columns)
+        raise Errors::InvalidError.new("Table name '#{table_name}' cannot be greater than 48 characters", 'MockStatement') if table_name.length > 48
+        raise Errors::AlreadyExistsError.new('Cannot create already existing table', 'MockStatement', nil, table_name) if @tables[table_name]
+
+        partition_key = primary_key.shift
+        partition_key_columns = partition_key_part(columns, partition_key)
+        clustering_columns = partition_key_part(columns, primary_key)
+        fields = fields(columns, partition_key, primary_key)
+        @tables[table_name] = Table.new(name, table_name, partition_key_columns, clustering_columns, fields)
+      end
+
+      def drop_table(table_name)
+        @tables.delete(table_name)
+      end
+
+      private
+
+      def partition_key_part(columns, primary_key)
+        primary_key.map { |name| Cassandra::Column.new(name, columns[name], :asc) }
+      end
+
+      def fields(columns, partition_key, primary_key)
+        columns.except(partition_key + primary_key).map { |name, type| Cassandra::Column.new(name, type, :asc) }
+      end
+
+    end
+  end
+end

data/lib/cassandra_mocks/result_page.rb

@@ -0,0 +1,24 @@
+module Cassandra
+  module Mocks
+    class ResultPage < Array
+
+      def last_page?
+        true
+      end
+
+      def next_page
+      end
+
+      def next_page_async
+        Cassandra::Future.value(next_page)
+      end
+
+      def paging_state
+      end
+
+      def execution_info
+      end
+
+    end
+  end
+end

data/lib/cassandra_mocks/session.rb

@@ -0,0 +1,117 @@
+module Cassandra
+  module Mocks
+    class Session
+      attr_reader :keyspace, :cluster
+
+      def initialize(keyspace, cluster)
+        @keyspace = keyspace
+        @cluster = cluster
+      end
+
+      def close_async
+        Cassandra::Future.value(nil)
+      end
+
+      def close
+        close_async.get
+      end
+
+      def prepare_async(cql)
+        Cassandra::Future.value(Statement.new(cql, []))
+      end
+
+      def prepare(cql)
+        prepare_async(cql).get
+      end
+
+      def execute_async(cql, *args)
+        if cql.is_a?(Cassandra::Statements::Batch)
+          futures = cql.statements.map do |batched_statement|
+            execute_async(batched_statement.statement, *batched_statement.args)
+          end
+          return Cassandra::Future.all(futures).then { ResultPage.new }
+        end
+
+        future = cql.is_a?(Statement) ? Cassandra::Future.value(cql.fill_params(args)) : prepare_async(cql)
+        future.then do |statement|
+          result = ResultPage.new
+          case statement.action
+            when :create_keyspace
+              cluster.add_keyspace(statement.args[:keyspace])
+            when :create_table
+              cluster.keyspace(keyspace).add_table(statement.args[:table], statement.args[:primary_key], statement.args[:columns])
+            when :insert
+              insert_query(result, statement)
+            when :update
+              update_query(statement)
+            when :truncate
+              cluster.keyspace(keyspace_for_statement(statement)).table(statement.args[:table]).rows.clear
+            when :drop_keyspace
+              cluster.drop_keyspace(statement.args[:keyspace])
+            when :drop_table
+              cluster.keyspace(keyspace_for_statement(statement)).drop_table(statement.args[:table])
+            when :select
+              result = select_query(statement)
+            when :delete
+              delete_query(statement)
+          end
+          result
+        end
+      end
+
+      def execute(cql)
+        execute_async(cql).get
+      end
+
+      def ==(rhs)
+        rhs.is_a?(Session) &&
+            rhs.keyspace == keyspace &&
+            rhs.cluster == cluster
+      end
+
+      private
+
+      def insert_query(result, statement)
+        check_exists = !!statement.args[:check_exists]
+        inserted = cluster.keyspace(keyspace_for_statement(statement)).table(statement.args[:table]).insert(statement.args[:values], check_exists: check_exists)
+        result << {'[applied]' => inserted} if check_exists
+      end
+
+      def select_query(statement)
+        table = cluster.keyspace(keyspace_for_statement(statement)).table(statement.args[:table])
+        options = statement.args[:filter].merge(limit: statement.args[:limit], order: statement.args[:order])
+        table.select(*statement.args[:columns], options)
+      end
+
+      def delete_query(statement)
+        table = cluster.keyspace(keyspace_for_statement(statement)).table(statement.args[:table])
+        table.delete(statement.args[:filter])
+      end
+
+      def update_query(statement)
+        table = cluster.keyspace(keyspace_for_statement(statement)).table(statement.args[:table])
+        rows_to_update = table.select('*', statement.args[:filter])
+        rows_to_update = [statement.args[:filter].dup] if rows_to_update.empty?
+        rows_to_update.each do |row|
+          updated_row = updated_row(row, statement)
+          cluster.keyspace(keyspace_for_statement(statement)).table(statement.args[:table]).insert(updated_row)
+        end
+      end
+
+      def updated_row(row, statement)
+        statement.args[:values].inject(row.dup) do |memo, (column, value)|
+          if value.is_a?(Statement::Arithmetic)
+            value.apply(memo)
+          else
+            memo.merge!(column => value)
+          end
+        end
+      end
+
+      def keyspace_for_statement(statement)
+        statement.args[:keyspace] || keyspace
+      end
+
+    end
+  end
+end

data/lib/cassandra_mocks/statement/arithmetic.rb

@@ -0,0 +1,19 @@
+module Cassandra
+  module Mocks
+    class Statement
+      class Arithmetic < Struct.new(:operation, :column, :amount)
+
+        def apply(row)
+          row.merge(column => (row[column] || 0).public_send(operator, amount))
+        end
+
+        private
+
+        def operator
+          operation == :plus ? :+ : :-
+        end
+
+      end
+    end
+  end
+end

data/lib/cassandra_mocks/statement/batch.rb

@@ -0,0 +1,12 @@
+module Cassandra
+  module Statements
+    class Batch
+      BatchedStatement = Struct.new(:statement, :args)
+
+      def add(statement, *args)
+        @statements << BatchedStatement.new(statement, args)
+      end
+
+    end
+  end
+end

data/lib/cassandra_mocks/statement/comparitor.rb

@@ -0,0 +1,41 @@
+module Cassandra
+  module Mocks
+    class Statement
+      class Comparitor < Struct.new(:operation, :column, :value)
+
+        COMPARISON_MAP = {
+            lt: [-1],
+            le: [-1, 0],
+            eq: [0],
+            ge: [0, 1],
+            gt: [1]
+        }
+
+        def initialize(*args)
+          super
+          @comparitor = COMPARISON_MAP[operation]
+        end
+
+        def check_against(row)
+          if column.is_a?(Array)
+            check_against_array(row[column])
+          else
+            @comparitor.include?(row[column] <=> value)
+          end
+        end
+
+        def check_against_array(row_values, index = 0, prev_result = false)
+          row_value = row_values[index]
+          comparison_value = value[index]
+          return prev_result unless row_value
+
+          comparison = @comparitor.include?(row_value <=> comparison_value)
+          return comparison if row_value != comparison_value
+
+          check_against_array(row_values, index+1, comparison)
+        end
+
+      end
+    end
+  end
+end

data/lib/cassandra_mocks/statement/token.rb

@@ -0,0 +1,37 @@
+module Cassandra
+  module Mocks
+    class Statement
+      class Token < Struct.new(:type, :value)
+        def normalized_value
+          case type
+            when :int
+              value.to_i
+            when :float
+              value.to_f
+            else
+              value
+          end
+        end
+
+        def respond_to?(method)
+          method_inquiry?(method) || super
+        end
+
+        def method_missing(method, *args)
+          if method_inquiry?(method)
+            method[/[^\?]+/].to_sym == type
+          else
+            super
+          end
+        end
+
+        private
+
+        def method_inquiry?(method)
+          method =~ /\?$/
+        end
+
+      end
+    end
+  end
+end

data/lib/cassandra_mocks/statement/tokenizer.rb

@@ -0,0 +1,123 @@
+module Cassandra
+  module Mocks
+    class Statement
+      class Tokenizer
+        #noinspection RubyStringKeysInHashInspection
+        KEYWORD_MAP = {
+            'CREATE' => :create,
+            'DROP' => :drop,
+            'TRUNCATE' => :truncate,
+            'PRIMARY' => :primary,
+            'KEY' => :key,
+            'TABLE' => :table,
+            'KEYSPACE' => :keyspace,
+            'INSERT' => :insert,
+            'UPDATE' => :update,
+            'SET' => :set,
+            'VALUES' => :values,
+            'SELECT' => :select,
+            'DELETE' => :delete,
+            'FROM' => :from,
+            'WHERE' => :where,
+            'ORDER' => :order,
+            'BY' => :by,
+            'ASC' => :asc,
+            'DESC' => :desc,
+            'LIMIT' => :limit,
+            'AND' => :and,
+            'IN' => :in,
+            'IF' => :if,
+            'NOT' => :not,
+            'EXISTS' => :exists,
+            '(' => :lparen,
+            ')' => :rparen,
+            '<' => :ltri,
+            '>' => :rtri,
+            ',' => :comma,
+            '.' => :dot,
+            '[' => :lbracket,
+            ']' => :rbracket,
+            '=' => :eql,
+            '+' => :plus,
+            '-' => :minus,
+            '*' => :star,
+            '?' => :parameter,
+        }
+
+        attr_reader :tokens
+
+        def initialize(cql)
+          @tokens = []
+          current_token = ''
+
+          in_string = false
+          in_name = false
+          prev_char = nil
+          tokenize(cql, current_token, in_name, in_string, prev_char)
+        end
+
+        def token_queue
+          Queue.new.tap do |queue|
+            tokens.each { |token| queue << token }
+          end
+        end
+
+        private
+
+        def tokenize(cql, current_token, in_name, in_string, prev_char)
+          cql.chars.each do |char|
+            if char == '"' && prev_char != '\\'
+              in_name = tokenize_string(:name, in_name, current_token)
+              current_token = '' unless in_name
+            elsif char == "'" && prev_char != '\\'
+              in_string = tokenize_string(:string, in_string, current_token)
+              current_token = '' unless in_string
+            elsif !in_name && !in_string && char == '.' && prev_char !~ /\d/
+              translate_multiple_tokens(char, current_token)
+              current_token = ''
+            elsif !in_name && !in_string && %w(, ( ) < > = ? + -).include?(char)
+              translate_multiple_tokens(char, current_token)
+              current_token = ''
+            elsif !in_name && !in_string && char == ' '
+              translate_token(current_token)
+              current_token = ''
+            elsif char == '\\'
+              # do nothing...
+            else
+              current_token << char
+            end
+            prev_char = char
+          end
+          translate_token(current_token) if current_token.present?
+        end
+
+        def translate_multiple_tokens(char, current_token)
+          translate_token(current_token)
+          translate_token(char)
+        end
+
+        def tokenize_string(type, in_string, current_token)
+          if in_string
+            @tokens << Token.new(type, current_token)
+            false
+          else
+            true
+          end
+        end
+
+        def translate_token(current_token)
+          if current_token.present?
+            @tokens << if current_token =~ /^\d+\.\d+$/
+                         Token.new(:float, current_token)
+                       elsif current_token =~ /^\d+$/
+                         Token.new(:int, current_token)
+                       else
+                         Token.new(KEYWORD_MAP[current_token.upcase] || :id, current_token)
+                       end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/cassandra_mocks/statement.rb

@@ -0,0 +1,364 @@
+module Cassandra
+  module Mocks
+    class Statement
+      attr_reader :cql, :action, :args
+
+      def initialize(cql, args)
+        @cql = cql
+        @input_args = param_queue(args)
+
+        type_token = next_token
+        @action = type_token.type
+        if type_token.create?
+          create_type_token = next_token
+          if create_type_token.table?
+            @action = :create_table
+            parse_create_table
+          else
+            @action = :create_keyspace
+            @args = {keyspace: next_token.value}
+          end
+        elsif type_token.truncate?
+          parse_truncate_query
+        elsif type_token.drop?
+          if next_token.keyspace?
+            @action = :drop_keyspace
+            @args = {keyspace: next_token.value}
+          else
+            @action = :drop_table
+            parse_truncate_query
+          end
+        elsif type_token.insert?
+          parse_insert_query
+        elsif type_token.update?
+          parse_update_query
+        elsif type_token.select?
+          parse_select_query
+        elsif type_token.delete?
+          next_token
+          parse_table_and_filter
+        end
+      end
+
+      def fill_params(params)
+        Statement.allocate.tap do |statement|
+          statement.cql = cql
+          statement.action = action
+          statement.args = args.dup
+          params = param_queue(params)
+          case action
+            when :insert
+              parameterize_args!(:values, params, statement)
+            when :select, :delete
+              parameterize_args!(:filter, params, statement)
+            when :update
+              parameterize_args!(:values, params, statement)
+              parameterize_args!(:filter, params, statement)
+          end
+        end
+      end
+
+      def bind(*args)
+        fill_params(args)
+      end
+
+      def ==(rhs)
+        rhs.is_a?(Statement) &&
+            rhs.action == action &&
+            rhs.args == args
+      end
+
+      protected
+
+      attr_writer :cql, :action, :args
+
+      private
+
+      attr_reader :last_token
+
+      def parameterize_args!(key, params, statement)
+        values = args[key].inject({}) do |memo, (column, value)|
+          updated_value = if value.is_a?(Arithmetic)
+                            Arithmetic.new(value.operation, value.column, pending_value(value.amount, params))
+                          elsif value.is_a?(Comparitor)
+                            if value.value.is_a?(Array)
+                              new_values = value.value.map { |value| pending_value(value, params) }
+                              Comparitor.new(value.operation, value.column, new_values)
+                            else
+                              Comparitor.new(value.operation, value.column, pending_value(value.value, params))
+                            end
+                          elsif value.is_a?(Array)
+                            value.map { |value| pending_value(value, params) }
+                          else
+                            pending_value(value, params)
+                          end
+          memo.merge!(column => updated_value)
+        end
+        statement.args.merge!(key => values)
+      end
+
+      def pending_value(value, params)
+        if value == :value_pending
+          raise Errors::InvalidError.new('Not enough params provided to #fill_params', 'MockStatement') if params.empty?
+          params.pop
+        else
+          value
+        end
+      end
+
+      def tokens
+        @tokens ||= Tokenizer.new(@cql).token_queue
+      end
+
+      def next_token
+        if tokens.empty?
+          Token.new(:eof, nil)
+        else
+          @last_token = tokens.pop
+        end
+      end
+
+      def parse_create_table
+        table_name_token = next_token
+        check_exists = if table_name_token.if?
+                         next_token
+                         next_token
+                         table_name_token = next_token
+                       end
+        table_name = table_name_token.value
+
+        next_token
+        column_name = next_token.value
+        column_type = next_token.value
+        primary_key = nil
+        if next_token.primary?
+          primary_key = [[column_name]]
+          2.times { next_token }
+        end
+
+        additional_columns = if tokens.empty?
+                               {}
+                             else
+                               parenthesis_values(:rparen, :primary).each_slice(2).inject({}) do |memo, (name, type)|
+                                 memo.merge!(name => type)
+                               end
+                             end
+
+        if !tokens.empty? && next_token.key?
+          next_token
+          primary_key_parts = parenthesis_values(:rparen)
+          partition_key = primary_key_parts.shift
+          partition_key = [partition_key] unless partition_key.is_a?(Array)
+          primary_key = [partition_key, *primary_key_parts]
+        end
+
+        @args = {table: table_name, check_exists: !!check_exists, columns: additional_columns.merge({column_name => column_type}), primary_key: primary_key}
+      end
+
+      def parse_truncate_query
+        keyspace_name, table_name = parsed_keyspace_and_table
+
+        @args = {keyspace: keyspace_name, table: table_name}
+      end
+
+      def parse_insert_query
+        next_token
+
+        keyspace_name, table_name = parsed_keyspace_and_table
+        next_token unless keyspace_name.nil?
+
+        insert_keys = parenthesis_values(:rparen)
+        2.times { next_token }
+        insert_values = parenthesis_values(:rparen)
+
+        values = insert_args(insert_keys, insert_values)
+        if next_token.if?
+          @args = {keyspace: keyspace_name, table: table_name, values: values, check_exists: true}
+        else
+          @args = {keyspace: keyspace_name, table: table_name, values: values}
+        end
+      end
+
+      def parse_update_query
+        keyspace_name, table_name = parsed_keyspace_and_table
+        next_token if keyspace_name
+        values = parsed_filter(:where)
+        filter = parsed_filter(:eof)
+        @args = {keyspace: keyspace_name, table: table_name, values: values, filter: filter}
+      end
+
+      def parse_select_query
+        select_columns = parenthesis_values(:from)
+        parse_table_and_filter
+        @args.merge!(columns: select_columns)
+      end
+
+      def parse_table_and_filter
+        keyspace_name, table_name = parsed_keyspace_and_table
+        next_token if keyspace_name
+
+        filter = parsed_filter(:limit, :order)
+
+        @args = {keyspace: keyspace_name, table: table_name, filter: filter}
+
+        if last_token.order?
+          next_token
+          @args.merge!(order: parse_select_order)
+        end
+
+        if last_token.limit?
+          limit = next_token.normalized_value
+          @args = @args.merge!(limit: limit)
+        end
+      end
+
+      def parse_select_order
+        order = {}
+        prev_column = nil
+        token = next_token
+        until token.eof? || token.limit?
+          if token.desc?
+            order[prev_column] = :desc
+          elsif token.asc?
+            order[prev_column] = :asc
+          elsif token.comma?
+          else
+            order[token.value] = :asc
+            prev_column = token.value
+          end
+          token = next_token
+        end
+        order
+      end
+
+      def parsed_filter(*end_tokens)
+        filter_keys = []
+        filter_values = []
+        until tokens.empty? || end_tokens.include?(last_token.type)
+          filter_keys << next_filter_key(next_token)
+
+          restrictor_token = next_token
+          if restrictor_token.type == :in
+            next_token
+            filter_values << parenthesis_values(:rparen)
+            next_token
+          elsif restrictor_token.ltri? || restrictor_token.rtri?
+            parse_comparison_restriction(filter_keys, filter_values, restrictor_token)
+          else
+            parse_single_restriction(filter_values)
+          end
+        end
+
+        insert_args(filter_keys, filter_values)
+      end
+
+      def parse_comparison_restriction(filter_keys, filter_values, restrictor_token)
+        value_token = next_token
+        eql_comparison = if value_token.type == :eql
+                           value_token = next_token
+                           true
+                         end
+        value = next_filter_key(value_token)
+
+        comparison_operator = comparison_operator(eql_comparison, restrictor_token)
+        filter_values << Comparitor.new(comparison_operator, filter_keys.last, value)
+        next_token
+      end
+
+      def next_filter_key(next_key)
+        if next_key.lparen?
+          parenthesis_values(:rparen)
+        else
+          next_key.normalized_value
+        end
+      end
+
+      def parse_single_restriction(filter_values)
+        value_token = next_token
+        next_token
+        value = value_token.normalized_value
+        update_value = update_value(last_token, value)
+        if update_value
+          value = update_value
+          next_token
+        end
+        filter_values << value
+      end
+
+      def comparison_operator(eql_comparison, restrictor_token)
+        if eql_comparison
+          restrictor_token.rtri? ? :ge : :le
+        else
+          restrictor_token.rtri? ? :gt : :lt
+        end
+      end
+
+      def update_value(prev_token, value)
+        if prev_token.plus? || prev_token.minus?
+          column = value
+          amount = next_token.normalized_value
+          Arithmetic.new(prev_token.type, column, amount)
+        end
+      end
+
+      def parsed_keyspace_and_table
+        keyspace_name = nil
+        table_name = next_token.value
+        if next_token.dot?
+          keyspace_name = table_name
+          table_name = next_token.value
+        end
+        [keyspace_name, table_name]
+      end
+
+      def parenthesis_values(*terminators)
+        [].tap do |insert_values|
+          until terminators.include?((key = next_token).type)
+            if key.lparen?
+              insert_values << parenthesis_values(:rparen)
+            elsif !key.comma?
+              insert_values << parameterized_value(key.normalized_value) unless key.comma?
+            end
+          end
+        end
+      end
+
+      def insert_args(insert_keys, insert_values)
+        insert_keys.count.times.inject({}) do |memo, index|
+          value = mapped_value(insert_values[index])
+          memo.merge!(insert_keys[index] => value)
+        end
+      end
+
+      def mapped_value(value)
+        if value.is_a?(Array)
+          value.map { |value| parameterized_value(value) }
+        elsif value.is_a?(Arithmetic)
+          updated_amount = parameterized_value(value.amount)
+          Arithmetic.new(value.operation, value.column, updated_amount)
+        elsif value.is_a?(Comparitor)
+          updated_amount = parameterized_value(value.value)
+          Comparitor.new(value.operation, value.column, updated_amount)
+        else
+          parameterized_value(value)
+        end
+      end
+
+      def parameterized_value(value)
+        if value == '?'
+          if @input_args.empty?
+            :value_pending
+          else
+            @input_args.pop
+          end
+        else
+          value
+        end
+      end
+
+      def param_queue(args)
+        Queue.new.tap { |queue| args.each { |arg| queue << arg } }
+      end
+    end
+  end
+end

data/lib/cassandra_mocks/table.rb

@@ -0,0 +1,223 @@
+module Cassandra
+  module Mocks
+    class Table < Cassandra::Table
+      def initialize(keyspace, name, partition_key, clustering_key, fields)
+        compaction = Cassandra::Table::Compaction.new('mock', {})
+        options = Cassandra::Table::Options.new({}, compaction, {}, false, 'mock')
+        column_map = column_map(partition_key, clustering_key, fields)
+        super(keyspace, name, partition_key, clustering_key, column_map, options, [])
+      end
+
+      def insert(attributes, options = {})
+        validate_columns!(attributes)
+        validate_primary_key_presence!(attributes)
+
+        prev_row_index = rows.find_index do |row|
+          row.slice(*primary_key_names) == attributes.slice(*primary_key_names)
+        end
+
+        if prev_row_index
+          return false if options[:check_exists]
+          rows[prev_row_index] = attributes
+        else
+          rows << attributes
+        end
+        true
+      end
+
+      def select(*columns)
+        filter = select_filter(columns)
+        limit = filter.delete(:limit)
+        order = select_order(filter)
+        unless filter.empty?
+          validate_partion_key_filter!(filter)
+          validate_clustering_column_filter!(filter)
+        end
+
+        filtered_rows = filtered_rows(filter)
+        sorted_rows = filtered_rows.sort do |lhs, rhs|
+          compare_rows(0, lhs, rhs, order)
+        end
+
+        sorted_rows = sorted_rows[0...limit] if limit
+
+        result_rows = sorted_rows.map do |row|
+          (columns.first == '*') ? row : row.slice(*columns)
+        end
+        ResultPage.new(result_rows)
+      end
+
+      def delete(filter)
+        rows_to_remove = select('*', filter)
+        @rows.reject! { |row| rows_to_remove.include?(row) }
+      end
+
+      def rows
+        @rows ||= []
+      end
+
+      # make #partition_key public
+      def partition_key
+        super
+      end
+
+      # make #clustering_columns public
+      def clustering_columns
+        super
+      end
+
+      private
+
+      def select_filter(columns)
+        columns.last.is_a?(Hash) ? columns.pop : {}
+      end
+
+      def select_order(filter)
+        (filter.delete(:order) || {}).inject(Hash.new(1)) do |memo, (key, value)|
+          memo.merge!(key => value == :asc ? 1 : -1)
+        end
+      end
+
+      def validate_columns!(attributes)
+        attributes.each do |column_name, value|
+          column = find_column(column_name)
+          unless column
+            raise Errors::InvalidError.new(%Q{Invalid column, "#{column_name}", specified}, 'MockStatement')
+          end
+
+          if value
+            case column.type
+              when 'double'
+                raise_unless_valid_type(column_name, Float, value)
+              when 'string'
+                raise_unless_valid_type(column_name, String, value)
+              when 'text'
+                raise_unless_valid_type(column_name, String, value)
+              when 'varchar'
+                raise_unless_valid_type(column_name, String, value)
+              when 'blob'
+                raise_unless_valid_type(column_name, String, value)
+              when 'int'
+                raise_unless_valid_type(column_name, Fixnum, value)
+              when 'uuid'
+                raise_unless_valid_type(column_name, Cassandra::Uuid, value)
+              when 'timeuuid'
+                raise_unless_valid_type(column_name, Cassandra::TimeUuid, value)
+              when 'timestamp'
+                raise_unless_valid_type(column_name, Time, value)
+            end
+          end
+        end
+      end
+
+      def raise_unless_valid_type(column_name, ruby_type, value)
+        unless value.is_a?(ruby_type)
+          raise Errors::InvalidError.new(%Q{Expected column "#{column_name}" to be of type "#{ruby_type}", got a(n) "#{value.class}"}, 'MockStatement')
+        end
+      end
+
+      def validate_primary_key_presence!(attributes)
+        primary_key_names.each do |column|
+          raise Errors::InvalidError.new(%Q{Invalid null primary key part, "#{column}"}, 'MockStatement') unless filter_has_column?(attributes, column)
+        end
+      end
+
+      def validate_clustering_column_filter!(filter)
+        prev_columns = []
+        clustering_key_names.inject(true) do |hit_column, column|
+          if filter_has_column?(filter, column)
+            raise Cassandra::Errors::InvalidError.new("Clustering key part(s) #{prev_columns.map(&:inspect) * ', '} must be restricted", 'MockStatement') unless hit_column
+          else
+            prev_columns << column
+          end
+          filter_has_column?(filter, column)
+        end
+      end
+
+      def filter_has_column?(filter, column)
+        filter[column]
+      end
+
+      def filtered_rows(filter)
+        filter ? apply_filter(filter) : rows
+      end
+
+      def apply_filter(filter)
+        rows.select do |row|
+          partial_row = filter_slices_row(filter, row)
+          filter.all? do |column, value|
+            if value.is_a?(Statement::Comparitor)
+              value.check_against(partial_row)
+            elsif value.is_a?(Array)
+              value.include?(partial_row[column])
+            else
+              partial_row[column] == value
+            end
+          end
+        end
+      end
+
+      def filter_slices_row(filter, row)
+        filter.keys.inject({}) do |memo, key, _|
+          value = if key.is_a?(Array)
+                    row.values_at(*key)
+                  else
+                    row[key]
+                  end
+          memo.merge!(key => value)
+        end
+      end
+
+      def validate_partion_key_filter!(filter)
+        missing_partition_keys = Set.new(partition_key_names) - filter.keys
+        raise Cassandra::Errors::InvalidError.new("Missing partition key part(s) #{missing_partition_keys.map(&:inspect) * ', '}", 'MockStatement') unless missing_partition_keys.empty?
+      end
+
+      def compare_rows(primary_key_index, lhs, rhs, order)
+        return 0 if primary_key_names[primary_key_index].nil?
+
+        if primary_key_part(lhs, primary_key_index) == primary_key_part(rhs, primary_key_index)
+          compare_rows(primary_key_index + 1, lhs, rhs, order)
+        else
+          comparison = primary_key_part(lhs, primary_key_index) <=> primary_key_part(rhs, primary_key_index)
+          order_comparison(comparison, order, primary_key_names[primary_key_index])
+        end
+      end
+
+      def order_comparison(comparison, order, primary_key)
+        comparison * order[primary_key]
+      end
+
+      def primary_key_part(row, primary_key_index)
+        row[primary_key_names[primary_key_index]]
+      end
+
+      def primary_key_names
+        partition_key_names + clustering_key_names
+      end
+
+      def partition_key_names
+        partition_key.map(&:name)
+      end
+
+      def clustering_key_names
+        clustering_columns.map(&:name)
+      end
+
+      def column_names
+        columns.map(&:name)
+      end
+
+      def find_column(name)
+        columns.find { |column| column.name == name }
+      end
+
+      def column_map(partition_key, clustering_key, fields)
+        (partition_key + clustering_key + fields).inject({}) do |memo, column|
+          memo.merge!(column.name => column)
+        end
+      end
+
+    end
+  end
+end

data/lib/cassandra_mocks/uuid.rb

@@ -0,0 +1,7 @@
+module Cassandra
+  class Uuid
+    def <=>(rhs)
+      to_s <=> rhs.to_s
+    end
+  end
+end

data/lib/cassandra_mocks.rb

@@ -0,0 +1,32 @@
+#--
+# Copyright 2014-2015 Thomas RM Rogers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+require 'cassandra'
+require 'active_support/all'
+require 'active_support/core_ext/class/attribute_accessors'
+
+require 'cassandra_mocks/result_page'
+require 'cassandra_mocks/table'
+require 'cassandra_mocks/statement/batch'
+require 'cassandra_mocks/statement/arithmetic'
+require 'cassandra_mocks/statement/comparitor'
+require 'cassandra_mocks/statement/token'
+require 'cassandra_mocks/statement/tokenizer'
+require 'cassandra_mocks/statement'
+require 'cassandra_mocks/keyspace'
+require 'cassandra_mocks/cluster'
+require 'cassandra_mocks/session'
+require 'cassandra_mocks/uuid'

data/lib/cassandra_model/mock_connection.rb

@@ -0,0 +1,15 @@
+module CassandraModel
+  class RawConnection
+    def cluster
+      @cluster ||= begin
+        Cassandra::Mocks::Cluster.new.tap do |cluster|
+          cluster.add_keyspace(config[:keyspace])
+        end
+      end
+    end
+
+    def session
+      @session ||= Cassandra::Mocks::Session.new(config[:keyspace], cluster)
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: cassandra_mocks
+version: !ruby/object:Gem::Version
+  version: 0.0.8.2
+platform: ruby
+authors:
+- Thomas RM Rogers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cassandra-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: |-
+  Cassandra mocking framework intended to replace having
+  a full blown Cassandra running for a unit testing environment. Aims to be a fast
+  and accurate representation of running CQL 3 against the Ruby Cassandra driver
+email: thomasrogers03@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/cassandra_mocks.rb
+- lib/cassandra_mocks/cluster.rb
+- lib/cassandra_mocks/keyspace.rb
+- lib/cassandra_mocks/result_page.rb
+- lib/cassandra_mocks/session.rb
+- lib/cassandra_mocks/statement.rb
+- lib/cassandra_mocks/statement/arithmetic.rb
+- lib/cassandra_mocks/statement/batch.rb
+- lib/cassandra_mocks/statement/comparitor.rb
+- lib/cassandra_mocks/statement/token.rb
+- lib/cassandra_mocks/statement/tokenizer.rb
+- lib/cassandra_mocks/table.rb
+- lib/cassandra_mocks/uuid.rb
+- lib/cassandra_model/mock_connection.rb
+homepage: https://www.github.com/thomasrogers03/cassandra_mocks
+licenses:
+- Apache License 2.0
+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: Cassandra mocking framework
+test_files: []