cassandra_mocks 0.0.13 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c063a1f6bef33dc9148256cfd940ed22beac02d
-  data.tar.gz: c21076920e07c9eef84b5fb1bc27dbeae2e3f50a
+  metadata.gz: 952c46e902eb98a2c45ff133302d2f867a9e3f06
+  data.tar.gz: 80aae79947b0bf4c7c7c6d3d7ecbf6724dc1549f
 SHA512:
-  metadata.gz: 34614c002d291f058af84a5391bcfa779e2ede158e390da826feb63ee87bb658805e94d1751953e5b0c651ab74fe6a0384552447ae57e392d729cfb28c4d4e09
-  data.tar.gz: b07c0efd1a83aaf4e5c1ff8ad01342db29f5dea130d944ae3f94fa4738d86b4cadf7f3146daaefdf5cbffe6e13d2ad0ac1b2a841f608c83dabd5ac88e52b4e8f
+  metadata.gz: 4b5bc8c274cbd897c234e41c4ac4ad5bc77d6db745733146b63866ecb77af307e34b490d50e5c45cf39dc500875dc81443444bd4da331ef369207fc3cf9b323b
+  data.tar.gz: 5c9411783f168d2228d8c3717166e5179f9ff28188240ee8d347fdbdf7284d8b94a820f410eb386b4fbe710e6904e3396a9e52058ecb957c55b77f03e558636c

data/lib/cassandra_mocks.rb

@@ -14,11 +14,14 @@
 # limitations under the License.
 #++
 
+require 'concurrent'
 require 'cassandra'
 require 'active_support/all'
 require 'active_support/core_ext/class/attribute_accessors'
 
 require 'cassandra_mocks/result_page'
+require 'cassandra_mocks/record'
+require 'cassandra_mocks/row'
 require 'cassandra_mocks/table'
 require 'cassandra_mocks/statement/batch'
 require 'cassandra_mocks/statement/arithmetic'

data/lib/cassandra_mocks/cluster.rb

@@ -6,7 +6,7 @@ module Cassandra
       def_delegator :@keyspaces, :[], :keyspace
 
       def initialize
-        @keyspaces = {}
+        @keyspaces = Concurrent::Map.new
       end
 
       def connect_async(keyspace = nil)
@@ -26,8 +26,11 @@ module Cassandra
         connect_async(keyspace).get
       end
 
-      def add_keyspace(name)
-        raise Errors::AlreadyExistsError.new('Cannot create already existing keyspace', 'MockStatement', name, nil) if @keyspaces[name]
+      def add_keyspace(name, ignore_existing)
+        if @keyspaces[name]
+          return if ignore_existing
+          raise Errors::AlreadyExistsError.new('Cannot create already existing keyspace', 'MockStatement', name, nil)
+        end
         @keyspaces[name] = Keyspace.new(name)
       end
 

data/lib/cassandra_mocks/keyspace.rb

@@ -5,11 +5,15 @@ module Cassandra
       def initialize(name)
         replication = Replication.new('mock', {})
         super(name, false, replication, {})
+        @tables = Concurrent::Map.new
       end
 
-      def add_table(table_name, primary_key, columns)
+      def add_table(table_name, primary_key, columns, ignore_existing)
         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]
+        if @tables[table_name]
+          return if ignore_existing
+          raise Errors::AlreadyExistsError.new('Cannot create already existing table', 'MockStatement', nil, table_name)
+        end
 
         partition_key = primary_key.shift
         partition_key_columns = partition_key_part(columns, partition_key)
@@ -29,7 +33,7 @@ module Cassandra
       end
 
       def fields(columns, partition_key, primary_key)
-        columns.except(partition_key + primary_key).map { |name, type| Cassandra::Column.new(name, type, :asc) }
+        columns.except(*(partition_key + primary_key)).map { |name, type| Cassandra::Column.new(name, type, :asc) }
       end
 
     end

data/lib/cassandra_mocks/record.rb

@@ -0,0 +1,6 @@
+module Cassandra
+  module Mocks
+    class Record < Struct.new(:values)
+    end
+  end
+end

data/lib/cassandra_mocks/row.rb

@@ -0,0 +1,90 @@
+module Cassandra
+  module Mocks
+    class Row
+      include MonitorMixin
+
+      attr_reader :clusters, :partition_key
+
+      def initialize(partition_key)
+        @clusters = {}
+        @partition_key = partition_key
+        super()
+      end
+
+      def insert_record(clustering_columns, record_values, check_exists)
+        synchronize do
+          record_cluster = record_cluster(clustering_columns[0..-2])
+          update_record(check_exists, clustering_columns, record_cluster, record_values)
+        end
+      end
+
+      def find_records(clustering_columns)
+        cluster = find_cluster(clustering_columns)
+        if cluster
+          [cluster_values(cluster, [*clustering_columns])].flatten.map(&:values)
+        else
+          []
+        end
+      end
+
+      def delete_records(clustering_columns)
+        synchronize do
+          if clustering_columns.any?
+            cluster = find_cluster(clustering_columns[0..-2])
+            cluster.delete(clustering_columns.last) if cluster
+          else
+            @clusters.clear
+          end
+        end
+      end
+
+      private
+
+      def cluster_values(cluster, values)
+        if cluster.is_a?(Record)
+          Record.new([*partition_key, *values, *cluster.values])
+        else
+          cluster.map do |clustering_key, child_cluster|
+            cluster_values(child_cluster, values + [clustering_key])
+          end
+        end
+      end
+
+      def find_cluster(clustering_columns)
+        clustering_columns.inject(@clusters) do |cluster, cluster_key|
+          cluster[cluster_key] if cluster
+        end
+      end
+
+      def record_cluster(partial_clustering_columns)
+        partial_clustering_columns.inject(clusters) do |memo, cluster_key|
+          memo[cluster_key] ||= {}
+        end
+      end
+
+      def update_record(check_exists, clustering_columns, record_cluster, record_values)
+        previous_record = record_cluster[clustering_columns.last]
+        if previous_record
+          update_if_not_exists(check_exists, previous_record, record_values)
+        else
+          create_record(clustering_columns, record_cluster, record_values)
+        end
+      end
+
+      def create_record(clustering_columns, record_cluster, record_values)
+        record_cluster[clustering_columns.last] = Record.new(record_values)
+        true
+      end
+
+      def update_if_not_exists(check_exists, previous_record, record_values)
+        if check_exists
+          false
+        else
+          previous_record.values = record_values
+          true
+        end
+      end
+
+    end
+  end
+end

data/lib/cassandra_mocks/session.rb

@@ -25,6 +25,9 @@ module Cassandra
       end
 
       def execute_async(cql, *args)
+        options = fetch_options(args)
+        args = options.fetch(:arguments) { args }
+
         if cql.is_a?(Cassandra::Statements::Batch)
           futures = cql.statements.map do |batched_statement|
             execute_async(batched_statement.statement, *batched_statement.args)
@@ -35,17 +38,18 @@ module Cassandra
         future = cql.is_a?(Statement) ? Cassandra::Future.value(cql.fill_params(args)) : prepare_async(cql)
         future.then do |statement|
           result = ResultPage.new
+          # noinspection RubyCaseWithoutElseBlockInspection
           case statement.action
             when :create_keyspace
-              cluster.add_keyspace(statement.args[:keyspace])
+              cluster.add_keyspace(statement.args[:keyspace], statement.args[:check_exists])
             when :create_table
-              cluster.keyspace(keyspace).add_table(statement.args[:table], statement.args[:primary_key], statement.args[:columns])
+              cluster.keyspace(keyspace).add_table(statement.args[:table], statement.args[:primary_key], statement.args[:columns], statement.args[:check_exists])
             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
+              cluster.keyspace(keyspace_for_statement(statement)).table(statement.args[:table]).clear
             when :drop_keyspace
               cluster.drop_keyspace(statement.args[:keyspace])
             when :drop_table
@@ -71,9 +75,19 @@ module Cassandra
 
       private
 
+      def fetch_options(args)
+        if args.last.is_a?(Hash)
+          args.pop
+        else
+          {arguments: args}
+        end
+      end
+
       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)
+        table = cluster.keyspace(keyspace_for_statement(statement)).table(statement.args[:table])
+        raise Cassandra::Errors::InvalidError.new('INSERT statement are not allowed on counter tables, use UPDATE instead', 'MockStatement') if table.counter_table?
+        inserted = table.insert(statement.args[:values], check_exists: check_exists)
         result << {'[applied]' => inserted} if check_exists
       end
 
@@ -93,15 +107,16 @@ module Cassandra
         rows_to_update = table.select('*', restriction: 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)
+          updated_row = updated_row(table, row, statement)
           cluster.keyspace(keyspace_for_statement(statement)).table(statement.args[:table]).insert(updated_row)
         end
       end
 
-      def updated_row(row, statement)
+      def updated_row(table, row, statement)
         statement.args[:values].inject(row.dup) do |memo, (column, value)|
           if value.is_a?(Statement::Arithmetic)
-            value.apply(memo)
+            raise Cassandra::Errors::InvalidError.new("Invalid operation (#{column} = #{column} + ?) for non counter column #{column}", 'MockStatement') unless table.counter_table?
+            value.apply!(memo)
           else
             memo.merge!(column => value)
           end

data/lib/cassandra_mocks/statement.rb

@@ -16,7 +16,7 @@ module Cassandra
             parse_create_table
           else
             @action = :create_keyspace
-            @args = {keyspace: next_token.value}
+            parse_create_keyspace
           end
         elsif type_token.truncate?
           parse_truncate_query
@@ -124,6 +124,16 @@ module Cassandra
         end
       end
 
+      def parse_create_keyspace
+        keyspace_name_token = next_token
+        check_exists = if keyspace_name_token.if?
+                         next_token
+                         next_token
+                         keyspace_name_token = next_token
+                       end
+        @args = {keyspace: keyspace_name_token.value, check_exists: !!check_exists}
+      end
+
       def parse_create_table
         table_name_token = next_token
         check_exists = if table_name_token.if?
@@ -159,7 +169,7 @@ module Cassandra
           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}
+        @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

data/lib/cassandra_mocks/statement/arithmetic.rb

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

data/lib/cassandra_mocks/table.rb

@@ -1,42 +1,96 @@
 module Cassandra
   module Mocks
     class Table < Cassandra::Table
+      extend Forwardable
+
+      def_delegator :@rows, :clear
+
       def initialize(keyspace, name, partition_key, clustering_key, fields)
+        @rows = Concurrent::Map.new { |hash, key| hash[key] = Row.new(key) }
+
         compaction = Cassandra::Table::Compaction.new('mock', {})
         options = Cassandra::Table::Options.new({}, compaction, {}, false, 'mock')
         column_map = column_map(partition_key, clustering_key, fields)
+
+        @counter_column = fields.find { |field| field.type.to_sym == :counter }
+        has_non_counters = !!fields.find { |field| field.type.to_sym != :counter }
+
+        if counter_column && has_non_counters
+          raise Cassandra::Errors::ConfigurationError.new("Cannot add counter column '#{counter_column.name}' to non-counter column family", 'MockStatement')
+        end
+
         super(keyspace, name, partition_key, clustering_key, column_map, options, [])
+        @column_map = columns.inject({}) do |memo, column|
+          memo.merge!(column.name => column)
+        end
+        @partition_key_set = Set.new(partition_key_names)
+      end
+
+      def rows
+        results = []
+        @rows.each_pair do |_, row|
+          row_results = record_attributes(row.find_records([]))
+          results << row_results
+        end
+        results.flatten
+      end
+
+      def counter_table?
+        !!counter_column
       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
+        row = @rows[attribute_partition_key(attributes)]
+        row.insert_record(attribute_clustering_key(attributes), attribute_fields(attributes), options[:check_exists])
       end
 
       def select(*columns)
         filter = select_filter(columns)
         limit = filter.delete(:limit)
         order = select_order(filter)
-        filter = filter.fetch(:restriction) { {} }
-        unless filter.empty?
-          validate_partion_key_filter!(filter)
-          validate_clustering_column_filter!(filter)
-          raise_if_fields_restricted!(filter)
+
+        order_keys_in_partition = order.keys.select { |column| partition_key_names.include?(column) }
+        if order_keys_in_partition.any?
+          raise Cassandra::Errors::InvalidError.new("Order by is currently only supported on the clustered columns of the PRIMARY KEY, got #{order_keys_in_partition * ', '}", 'MockStatement')
+        end
+
+        missing_ordering_keys = order.keys.select { |column| !column_names.include?(column) }
+        if missing_ordering_keys.any?
+          raise Cassandra::Errors::InvalidError.new("Order by on unknown column(s) #{missing_ordering_keys * ', '}", 'MockStatement')
+        end
+
+        out_of_order = order.keys.each.with_index.any? { |column, index| clustering_key_names[index] != column }
+        if out_of_order
+          raise Cassandra::Errors::InvalidError.new("Order by currently only support the ordering of columns following their declared order in the PRIMARY KEY (expected #{clustering_key_names * ', '} got #{order.keys * ', '})", 'MockStatement')
+        end
+
+        inconsistent_order = (order.values.uniq.count > 1)
+        if inconsistent_order
+          raise Cassandra::Errors::InvalidError.new('Ordering direction must be consistent across all clustering columns', 'MockStatement')
         end
 
-        filtered_rows = filtered_rows(filter)
+        filter = filter.fetch(:restriction) { {} }
+        validate_filter!(filter)
+
+        filtered_rows = if filter.any?
+                          partition_key = attribute_partition_key(filter)
+                          partition_range = (partition_key.pop if partition_key.last.is_a?(Array))
+                          cluster_filter = filter.except(*partition_key_names)
+                          cluster_key = attribute_partial_clustering_key(cluster_filter)
+                          _, cluster_slice = cluster_filter.find do |_, value|
+                            restriction_is_slice?(value)
+                          end
+
+                          records = partially_filtered_rows(partition_range, partition_key, cluster_key)
+                          rows = record_attributes(records)
+                          filtered_rows(cluster_slice, rows)
+                        else
+                          self.rows
+                        end
+
         sorted_rows = filtered_rows.sort do |lhs, rhs|
           compare_rows(0, lhs, rhs, order)
         end
@@ -50,12 +104,41 @@ module Cassandra
       end
 
       def delete(filter)
-        rows_to_remove = select('*', restriction: filter)
-        @rows.reject! { |row| rows_to_remove.include?(row) }
+        validate_filter!(filter)
+        row = @rows[attribute_partition_key(filter)]
+        row.delete_records(attribute_partial_clustering_key(filter))
       end
 
-      def rows
-        @rows ||= []
+      def attribute_partition_key(attributes)
+        partition_key_names.map { |column| attributes[column] }
+      end
+
+      def attribute_clustering_key(attributes)
+        clustering_key_names.map do |column|
+          value = attributes[column]
+          value unless restriction_is_slice?(value)
+        end
+      end
+
+      def attribute_partial_clustering_key(attributes)
+        attribute_clustering_key(attributes).compact
+      end
+
+      def attribute_fields(attributes)
+        field_names.map { |column| attributes[column] }
+      end
+
+      def restriction_is_slice?(value)
+        value.is_a?(Statement::Comparitor) || value.is_a?(Array)
+      end
+
+      def validate_filter!(filter)
+        unless filter.empty?
+          validate_range_query!(filter)
+          validate_partition_key_filter!(filter)
+          validate_clustering_column_filter!(filter)
+          raise_if_fields_restricted!(filter)
+        end
       end
 
       # make #partition_key public
@@ -70,8 +153,11 @@ module Cassandra
 
       private
 
+      attr_reader :counter_column
+      def_delegator :@column_map, :[], :find_column
+
       def select_filter(columns)
-        columns.last.is_a?(Hash) ? columns.pop : {}
+        columns.last.is_a?(Hash) ? columns.pop.dup : {}
       end
 
       def select_order(filter)
@@ -145,42 +231,15 @@ module Cassandra
         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)
-              if value.first.is_a?(Statement::Comparitor)
-                value.all? { |value| value.check_against(partial_row) }
-              else
-                value.include?(partial_row[column])
-              end
-            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)
+      def validate_range_query!(filter)
+        invalid_partition_range_column = partition_key_names[0..-2].find { |column| filter[column].is_a?(Array) }
+        if invalid_partition_range_column
+          raise Cassandra::Errors::InvalidError.new("Partition KEY part #{invalid_partition_range_column} cannot be restricted by IN relation (only the last part of the partition key can)", 'MockStatement')
         end
       end
 
-      def validate_partion_key_filter!(filter)
-        missing_partition_keys = Set.new(partition_key_names) - filter.keys
+      def validate_partition_key_filter!(filter)
+        missing_partition_keys = @partition_key_set - filter.keys
         raise Cassandra::Errors::InvalidError.new("Missing partition key part(s) #{missing_partition_keys.map(&:inspect) * ', '}", 'MockStatement') unless missing_partition_keys.empty?
       end
 
@@ -203,6 +262,61 @@ module Cassandra
         row[primary_key_names[primary_key_index]]
       end
 
+      def record_attributes(records)
+        records.map do |record|
+          attributes = {}
+          column_names.each.with_index do |column, index|
+            attributes[column] = record[index]
+          end
+          attributes
+        end
+      end
+
+      def partially_filtered_rows(partition_range, partition_key, cluster_key)
+        if partition_range
+          partition_range_records(partition_range, partition_key, cluster_key)
+        else
+          records_for_row(partition_key, cluster_key)
+        end
+      end
+
+      def partition_range_records(partition_range, partition_key, cluster_key)
+        partition_range.map do |part|
+          records_for_row(partition_key + [part], cluster_key)
+        end.flatten(1)
+      end
+
+      def records_for_row(partition_key, cluster_key)
+        row = @rows[partition_key]
+        row.find_records(cluster_key)
+      end
+
+      def filtered_rows(cluster_slice, rows)
+        cluster_slice ? apply_filter(cluster_slice, rows) : rows
+      end
+
+      def apply_filter(cluster_slice, rows)
+        rows.select do |row|
+          partial_row = partial_row(cluster_slice, row)
+
+          if cluster_slice.is_a?(Statement::Comparitor)
+            cluster_slice.check_against(partial_row)
+          elsif cluster_slice.is_a?(Array)
+            cluster_slice.all? { |value| value.check_against(partial_row) }
+          end
+        end
+      end
+
+      def partial_row(cluster_slice, row)
+        comparitor = cluster_slice.is_a?(Statement::Comparitor) ? cluster_slice : cluster_slice.first
+        value = if comparitor.column.is_a?(Array)
+                  row.values_at(*comparitor.column)
+                else
+                  row[comparitor.column]
+                end
+        {comparitor.column => value}
+      end
+
       def primary_key_names
         partition_key_names + clustering_key_names
       end
@@ -219,8 +333,8 @@ module Cassandra
         columns.map(&:name)
       end
 
-      def find_column(name)
-        columns.find { |column| column.name == name }
+      def field_names
+        column_names - (partition_key_names + clustering_key_names)
       end
 
       def column_map(partition_key, clustering_key, fields)

metadata

@@ -1,29 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: cassandra_mocks
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 1.0.8
 platform: ruby
 authors:
 - Thomas RM Rogers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-14 00:00:00.000000000 Z
+date: 2016-05-12 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'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: 2.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
         version: '1.1'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -52,7 +72,9 @@ files:
 - lib/cassandra_mocks.rb
 - lib/cassandra_mocks/cluster.rb
 - lib/cassandra_mocks/keyspace.rb
+- lib/cassandra_mocks/record.rb
 - lib/cassandra_mocks/result_page.rb
+- lib/cassandra_mocks/row.rb
 - lib/cassandra_mocks/session.rb
 - lib/cassandra_mocks/statement.rb
 - lib/cassandra_mocks/statement/arithmetic.rb