redis_counters 1.3.0

data/spec/redis_counters/unique_hash_counter_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe RedisCounters::UniqueHashCounter do
+  let(:redis) { MockRedis.new }
+  let(:unique_list_postfix) { described_class.const_get(:UNIQUE_LIST_POSTFIX) }
+
+  let(:options) { {
+      :counter_name => :test_counter,
+      :field_name   => :test_field,
+      :unique_list  => { :list_class => RedisCounters::UniqueValuesLists::Blocking }
+  } }
+
+  let(:counter) { described_class.new(redis, options) }
+
+  context '#partitions' do
+    let(:options) { {
+        :counter_name => :visits_by_day,
+        :field_name => 'dd',
+        :partition_keys => [:date],
+        :unique_list  => {
+            :list_class => RedisCounters::UniqueValuesLists::NonBlocking,
+            :value_keys => [:sid],
+            :cluster_keys => [:p1],
+            :partition_keys => [:p2]
+        }
+    } }
+
+    before { counter.process(:date => '2013-10-17', :p1 => '2', :p2 => '3', :sid => '1') }
+
+    it { expect(counter.partitions).to have(1).partitions }
+    it { expect(counter.partitions.first).to include ({:date => '2013-10-17'}) }
+  end
+
+  it { expect(counter).to be_a_kind_of RedisCounters::HashCounter }
+
+  context 'when unique_list not given' do
+    let(:options) { {
+        :counter_name => :test_counter,
+        :field_name   => :test_field
+    } }
+
+    it { expect { counter.process }.to raise_error KeyError }
+  end
+
+  context 'when only partition_keys and partition_keys given' do
+    let(:options) { {
+        :counter_name   => :test_counter,
+        :field_name     => :test_field,
+        :group_keys => [:param1],
+        :partition_keys => [:date],
+        :unique_list  => {
+          :list_class => RedisCounters::UniqueValuesLists::Blocking,
+          :value_keys => [:sid],
+          :cluster_keys => [:param2],
+          :partition_keys => [:date]
+        }
+    } }
+
+    before { 2.times { counter.process(:param1 => 1, :param2 => 2, :date => '2013-04-27', :sid => 1) } }
+    before { 2.times { counter.process(:param1 => 1, :param2 => 2, :date => '2013-04-27', :sid => 2) } }
+    before { 2.times { counter.process(:param1 => 2, :param2 => 2, :date => '2013-04-27', :sid => 3) } }
+    before { 2.times { counter.process(:param1 => 2, :param2 => 1, :date => '2013-04-28', :sid => 1) } }
+    before { 2.times { counter.process(:param1 => 2, :param2 => 1, :date => '2013-04-28', :sid => 5) } }
+    before { 2.times { counter.process(:param1 => 2, :param2 => 1, :date => '2013-04-27', :sid => 4) } }
+    before { 2.times { counter.process(:param1 => 2, :param2 => 1, :date => '2013-04-27', :sid => 1) } }
+    before { 2.times { counter.process(:param1 => 2, :param2 => 1, :date => '2013-04-28', :sid => 4) } }
+    before { 2.times { counter.process(:param1 => 2, :param2 => 1, :date => '2013-04-28', :sid => 4) } }
+    before { 2.times { counter.process(:param1 => 2, :param2 => 1, :date => '2013-04-27', :sid => 5) } }
+
+    it { expect(redis.keys('*')).to have(7).key }
+
+    it { expect(redis.keys('*')).to include 'test_counter:2013-04-27' }
+    it { expect(redis.hget('test_counter:2013-04-27', '1')).to eq 2.to_s }
+    it { expect(redis.hget('test_counter:2013-04-27', '2')).to eq 2.to_s }
+    it { expect(redis.hget('test_counter:2013-04-28', '2')).to eq 2.to_s }
+
+    it { expect(redis.lrange('test_counter_uq:1:partitions', 0, -1)).to eq ['2013-04-28', '2013-04-27'] }
+    it { expect(redis.lrange('test_counter_uq:2:partitions', 0, -1)).to eq ['2013-04-27'] }
+    it { expect(redis.smembers('test_counter_uq:1:2013-04-27')).to eq ['4'] }
+    it { expect(redis.smembers('test_counter_uq:2:2013-04-27')).to eq ['3', '2', '1'] }
+    it { expect(redis.smembers('test_counter_uq:1:2013-04-28')).to eq ['5', '1'] }
+  end
+end

data/spec/redis_counters/unique_values_lists/blocking_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe RedisCounters::UniqueValuesLists::Blocking do
+  it_behaves_like 'unique_values_lists/common'
+  it_behaves_like 'unique_values_lists/set'
+
+  context 'when check partitions list' do
+    let(:redis) { MockRedis.new }
+    let(:values) { rand(10) + 1 }
+    let(:partitions_list_postfix) { described_class.const_get(:PARTITIONS_LIST_POSTFIX) }
+
+    let(:counter) { described_class.new(redis, options) }
+
+    context 'when group and partition keys given' do
+      let(:options) { {
+        :counter_name   => :test_counter,
+        :value_keys     => [:param0, :param1],
+        :cluster_keys   => [:param2],
+        :partition_keys => [:param3, :param4]
+      } }
+
+      before { values.times { counter.process(:param0 => 1, :param1 => 2, :param2 => :cluster1, :param3 => :part1, :param4 => :part2) } }
+      before { values.times { counter.process(:param0 => 2, :param1 => 1, :param2 => :cluster1, :param3 => :part1, :param4 => :part2) } }
+      before { values.times { counter.process(:param0 => 3, :param1 => 2, :param2 => :cluster1, :param3 => :part2, :param4 => :part2) } }
+      before { values.times { counter.process(:param0 => 4, :param1 => 5, :param2 => :cluster2, :param3 => :part1, :param4 => :part2) } }
+
+      it { expect(redis.keys('*')).to have(5).key }
+
+      context 'when check partitions' do
+        it { expect(redis.lrange("test_counter:cluster1:#{partitions_list_postfix}", 0, -1)).to be_true }
+        it { expect(redis.lrange("test_counter:cluster2:#{partitions_list_postfix}", 0, -1)).to be_true }
+
+        it { expect(redis.lrange("test_counter:cluster1:#{partitions_list_postfix}", 0, -1)).to have(2).keys }
+        it { expect(redis.lrange("test_counter:cluster2:#{partitions_list_postfix}", 0, -1)).to have(1).keys }
+
+        it { expect(redis.lrange("test_counter:cluster1:#{partitions_list_postfix}", 0, -1)).to include 'part1:part2' }
+        it { expect(redis.lrange("test_counter:cluster1:#{partitions_list_postfix}", 0, -1)).to include 'part2:part2' }
+        it { expect(redis.lrange("test_counter:cluster2:#{partitions_list_postfix}", 0, -1)).to include 'part1:part2' }
+      end
+
+      context 'when check values' do
+        it { expect(redis.exists("test_counter:cluster1:part1:part2")).to be_true }
+        it { expect(redis.exists("test_counter:cluster1:part2:part2")).to be_true }
+        it { expect(redis.exists("test_counter:cluster2:part1:part2")).to be_true }
+
+        it { expect(redis.smembers("test_counter:cluster1:part1:part2")).to have(2).keys }
+        it { expect(redis.smembers("test_counter:cluster1:part2:part2")).to have(1).keys }
+        it { expect(redis.smembers("test_counter:cluster2:part1:part2")).to have(1).keys }
+
+        it { expect(redis.smembers("test_counter:cluster1:part1:part2")).to include '1:2' }
+        it { expect(redis.smembers("test_counter:cluster1:part1:part2")).to include '2:1' }
+        it { expect(redis.smembers("test_counter:cluster1:part2:part2")).to include '3:2' }
+        it { expect(redis.smembers("test_counter:cluster2:part1:part2")).to include '4:5' }
+      end
+    end
+
+    context 'when no cluster keys given, but partition keys given' do
+      let(:options) { {
+        :counter_name   => :test_counter,
+        :value_keys     => [:param0, :param1],
+        :partition_keys => [:param3, :param4]
+      } }
+
+      before { values.times { counter.process(:param0 => 1, :param1 => 2, :param3 => :part1, :param4 => :part2) } }
+      before { values.times { counter.process(:param0 => 2, :param1 => 1, :param3 => :part1, :param4 => :part2) } }
+      before { values.times { counter.process(:param0 => 3, :param1 => 2, :param3 => :part2, :param4 => :part2) } }
+      before { values.times { counter.process(:param0 => 4, :param1 => 5, :param3 => :part1, :param4 => :part2) } }
+
+      it { expect(redis.keys('*')).to have(3).key }
+
+      context 'when check partitions' do
+        it { expect(redis.exists("test_counter:#{partitions_list_postfix}")).to be_true }
+
+        it { expect(redis.lrange("test_counter:#{partitions_list_postfix}", 0, -1)).to have(2).keys }
+
+        it { expect(redis.lrange("test_counter:#{partitions_list_postfix}", 0, -1)).to include 'part1:part2' }
+        it { expect(redis.lrange("test_counter:#{partitions_list_postfix}", 0, -1)).to include 'part2:part2' }
+      end
+
+      context 'when check values' do
+        it { expect(redis.exists("test_counter:part1:part2")).to be_true }
+        it { expect(redis.exists("test_counter:part2:part2")).to be_true }
+
+        it { expect(redis.smembers("test_counter:part1:part2")).to have(3).keys }
+        it { expect(redis.smembers("test_counter:part2:part2")).to have(1).keys }
+
+        it { expect(redis.smembers("test_counter:part1:part2")).to include '1:2' }
+        it { expect(redis.smembers("test_counter:part1:part2")).to include '2:1' }
+        it { expect(redis.smembers("test_counter:part2:part2")).to include '3:2' }
+        it { expect(redis.smembers("test_counter:part1:part2")).to include '4:5' }
+      end
+    end
+  end
+end

data/spec/redis_counters/unique_values_lists/expirable_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe RedisCounters::UniqueValuesLists::Expirable do
+  it_behaves_like 'unique_values_lists/common'
+  it_behaves_like 'unique_values_lists/expirable'
+end

data/spec/redis_counters/unique_values_lists/non_blicking_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe RedisCounters::UniqueValuesLists::NonBlocking do
+  it_behaves_like 'unique_values_lists/common'
+  it_behaves_like 'unique_values_lists/set'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec'
+require 'mock_redis'
+require 'timecop'
+
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+
+require 'simplecov'
+SimpleCov.start('test_frameworks')
+
+require 'redis_counters'
+
+# require helpers
+support_dir = File.expand_path(File.join('..', 'support'), __FILE__)
+Dir[File.join(support_dir, '**', '*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  config.backtrace_exclusion_patterns = [/lib\/rspec\/(core|expectations|matchers|mocks)/]
+  config.color_enabled = true
+  config.formatter = 'documentation'
+  config.order = 'random'
+end

data/spec/support/unique_values_lists/common.rb

@@ -0,0 +1,563 @@
+# coding: utf-8
+shared_examples_for 'unique_values_lists/common' do
+  let(:redis) { MockRedis.new }
+  let(:values) { rand(10) + 1 }
+
+  let(:options) { {
+    :counter_name => :test_counter,
+    :value_keys   => [:param0]
+  } }
+
+  let(:counter) { described_class.new(redis, options) }
+
+  context '#add' do
+    context 'when value_keys not given' do
+      let(:options) { {:counter_name => :test_counter} }
+
+      it { expect { counter.add }.to raise_error KeyError }
+    end
+
+    context 'when unknown value_key given' do
+      let(:options) { {
+        :counter_name => :test_counter,
+        :value_keys   => [:param0, :param1]
+      } }
+
+      it { expect { counter.add(:param1 => 1) }.to raise_error KeyError }
+    end
+
+    context 'when unknown cluster_key given' do
+      let(:options) { {
+        :counter_name => :test_counter,
+        :value_keys   => [:param0],
+        :cluster_keys   => [:param1, :param2],
+      } }
+
+      it { expect { counter.add(:param0 => 1, :param1 => 2) }.to raise_error KeyError }
+    end
+
+    context 'when unknown partition_key given' do
+      let(:options) { {
+        :counter_name   => :test_counter,
+        :value_keys     => [:param0],
+        :partition_keys => [:param1, :param2],
+      } }
+
+      it { expect { counter.add(:param0 => 1, :param1 => 2) }.to raise_error KeyError }
+    end
+
+    context 'when block given' do
+      let(:options) { {
+        :counter_name   => :test_counter,
+        :value_keys     => [:param0]
+      } }
+
+      context 'when item added' do
+        it { expect { |b| counter.add(:param0 => 1, &b) }.to yield_with_args(redis) }
+        it { expect(counter.add(:param0 => 1)).to be_true }
+      end
+
+      context 'when item not added' do
+        before { counter.add(:param0 => 1) }
+
+        it { expect { |b| counter.add(:param0 => 1, &b) }.to_not yield_with_args(redis) }
+        it { expect(counter.add(:param0 => 1)).to be_false }
+      end
+    end
+  end
+
+  context '#has_value?' do
+    context 'when cluster keys given and partition keys given' do
+      let(:options) { {
+          :counter_name   => :test_counter,
+          :value_keys     => [:param0],
+          :cluster_keys   => [:cluster],
+          :partition_keys => [:part]
+      } }
+
+      let(:cluster1) { {:cluster => :cluster1} }
+      let(:cluster2) { {:cluster => :cluster2} }
+
+      before { values.times { counter.add(:param0 => 1, :cluster => :cluster1, :part => :part1) } }
+      before { values.times { counter.add(:param0 => 2, :cluster => :cluster2, :part => :part2) } }
+
+      it { expect(counter.has_value?(cluster1.merge(:param0 => 1))).to be_true }
+      it { expect(counter.has_value?(cluster1.merge(:param0 => 2))).to be_false }
+      it { expect(counter.has_value?(cluster2.merge(:param0 => 1))).to be_false }
+      it { expect(counter.has_value?(cluster2.merge(:param0 => 2))).to be_true }
+    end
+
+    # check no cluster raise
+    # check unknown cluster raise
+  end
+
+  context '#partitions' do
+    let(:cluster1_subcluster1) { {:cluster => :cluster1, :subcluster => :subcluster1} }
+    let(:cluster1_subcluster2) { {:cluster => :cluster1, :subcluster => :subcluster2} }
+    let(:cluster1_subcluster3) { {:cluster => :cluster1, :subcluster => :subcluster3} }
+    let(:cluster2_subcluster1) { {:cluster => :cluster2, :subcluster => :subcluster1} }
+
+    let(:part1_subpart1) { {:part => 'part1', :subpart => 'subpart1'}.with_indifferent_access }
+    let(:part1_subpart2) { {:part => 'part1', :subpart => 'subpart2'}.with_indifferent_access }
+    let(:part2_subpart1) { {'part' => 'part2', :subpart => 'subpart1'}.with_indifferent_access }
+
+    context 'when cluster and partition keys given' do
+      let(:options) { {
+        :counter_name   => :test_counter,
+        :value_keys     => [:param0, :param1],
+        :cluster_keys     => [:cluster, :subcluster],
+        :partition_keys => [:part, :subpart]
+      } }
+
+      # 2 разных знач в одном кластере и партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      before { values.times { counter.add(:param0 => 1, :param1 => 3, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      # дубль знач в другой партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart3) } }
+      # дубль знач в другом кластере
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster3, :part => :part1, :subpart => :subpart1) } }
+      # новое значение в новой подпартиции
+      before { values.times { counter.add(:param0 => 3, :param1 => 4, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart2) } }
+      # новое значение в новой партиции
+      before { values.times { counter.add(:param0 => 4, :param1 => 5, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part2, :subpart => :subpart1) } }
+      # новое значение в новом кластере
+      before { values.times { counter.add(:param0 => 5, :param1 => 6, :cluster => :cluster2, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      # новое значение в новом подкластере
+      before { values.times { counter.add(:param0 => 6, :param1 => 7, :cluster => :cluster1, :subcluster => :subcluster2, :part => :part1, :subpart => :subpart1) } }
+
+      context 'when no cluster given' do
+        it { expect { counter.partitions }.to raise_error ArgumentError }
+      end
+
+      context 'when no leaf cluster given' do
+        it { expect { counter.partitions(:cluster => :cluster1) }.to raise_error KeyError }
+      end
+
+      context 'when unknown cluster given' do
+        it { expect(counter.partitions({:cluster => :unknown_cluster, :subcluster => :subcluster})).to have(0).partitions }
+      end
+
+      context 'when no partition given' do
+        it { expect(counter.partitions(cluster1_subcluster1)).to have(3).partitions }
+        it { expect(counter.partitions(cluster1_subcluster1).first).to eq part1_subpart1 }
+        it { expect(counter.partitions(cluster1_subcluster1).second).to eq part1_subpart2 }
+        it { expect(counter.partitions(cluster1_subcluster1).third).to eq part2_subpart1 }
+        #
+        it { expect(counter.partitions(cluster2_subcluster1)).to have(1).partitions }
+        it { expect(counter.partitions(cluster2_subcluster1).first).to eq part1_subpart1 }
+      end
+
+      context 'when not leaf partition given' do
+        it { expect(counter.partitions(cluster1_subcluster1.merge(:part => :part1))).to have(2).partitions }
+        it { expect(counter.partitions(cluster1_subcluster1.merge(:part => :part1)).first).to eq part1_subpart1 }
+        it { expect(counter.partitions(cluster1_subcluster1.merge(:part => :part1)).second).to eq part1_subpart2 }
+      end
+
+      context 'when leaf partition given' do
+        it { expect(counter.partitions(cluster1_subcluster1.merge(:part => :part1, 'subpart' => 'subpart1'))).to have(1).partitions }
+        it { expect(counter.partitions(cluster1_subcluster1.merge(:part => :part1, 'subpart' => 'subpart1')).first).to eq part1_subpart1 }
+      end
+    end
+
+    context 'when not cluster keys given and partition keys given' do
+      let(:options) { {
+        :counter_name   => :test_counter,
+        :value_keys     => [:param0, :param1],
+        :partition_keys => [:part, :subpart]
+      } }
+
+      # 2 разных знач в одной партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :part => :part1, :subpart => :subpart1) } }
+      before { values.times { counter.add(:param0 => 1, :param1 => 3, :part => :part1, :subpart => :subpart1) } }
+      # дубль знач в другой партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :part => :part1, :subpart => :subpart3) } }
+      # новое значение в новой подпартиции
+      before { values.times { counter.add(:param0 => 3, :param1 => 4, :part => :part1, :subpart => :subpart2) } }
+      # новое значение в новой партиции
+      before { values.times { counter.add(:param0 => 4, :param1 => 5, :part => :part2, :subpart => :subpart1) } }
+
+      context 'when no cluster given' do
+        it { expect { counter.partitions }.to_not raise_error KeyError }
+      end
+
+      context 'when no partition given' do
+        it { expect(counter.partitions).to have(3).partitions }
+        it { expect(counter.partitions.first).to eq part1_subpart1 }
+        it { expect(counter.partitions.second).to eq part1_subpart2 }
+        it { expect(counter.partitions.third).to eq part2_subpart1 }
+      end
+
+      context 'when not leaf partition given' do
+        it { expect(counter.partitions(:part => :part1)).to have(2).partitions }
+        it { expect(counter.partitions(:part => :part1).first).to eq part1_subpart1 }
+        it { expect(counter.partitions(:part => :part1).second).to eq part1_subpart2 }
+      end
+
+      context 'when leaf partition given' do
+        it { expect(counter.partitions(:part => :part1, 'subpart' => 'subpart1')).to have(1).partitions }
+        it { expect(counter.partitions(:part => :part1, 'subpart' => 'subpart1').first).to eq part1_subpart1 }
+      end
+    end
+
+    context 'when cluster keys given and partition keys not given' do
+      let(:options) { {
+        :counter_name   => :test_counter,
+        :value_keys     => [:param0, :param1],
+        :cluster_keys     => [:cluster, :subcluster]
+      } }
+
+      # 2 разных знач в одном кластере
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster1) } }
+      before { values.times { counter.add(:param0 => 1, :param1 => 3, :cluster => :cluster1, :subcluster => :subcluster1) } }
+      # дубль знач в другом кластере
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster3) } }
+      # новое значение в новом кластере
+      before { values.times { counter.add(:param0 => 5, :param1 => 6, :cluster => :cluster2, :subcluster => :subcluster1) } }
+      # новое значение в новом подкластере
+      before { values.times { counter.add(:param0 => 6, :param1 => 7, :cluster => :cluster1, :subcluster => :subcluster2) } }
+
+
+      context 'when no partition given' do
+        it { expect(counter.partitions(cluster1_subcluster1)).to have(1).partitions }
+        it { expect(counter.partitions(cluster1_subcluster1).first).to eq Hash.new }
+
+        it { expect(counter.partitions(cluster2_subcluster1)).to have(1).partitions }
+        it { expect(counter.partitions(cluster2_subcluster1).first).to eq Hash.new }
+      end
+    end
+  end
+
+  context '#data' do
+    let(:cluster1_subcluster1) { {:cluster => :cluster1, :subcluster => :subcluster1} }
+    let(:cluster1_subcluster2) { {:cluster => :cluster1, :subcluster => :subcluster2} }
+    let(:cluster1_subcluster3) { {:cluster => :cluster1, :subcluster => :subcluster3} }
+    let(:cluster2_subcluster1) { {:cluster => :cluster2, :subcluster => :subcluster1} }
+
+    let(:part1_subpart1) { {:part => 'part1', :subpart => 'subpart1'}.with_indifferent_access }
+    let(:part1_subpart2) { {:part => 'part1', :subpart => 'subpart2'}.with_indifferent_access }
+    let(:part2_subpart1) { {'part' => 'part2', :subpart => 'subpart1'}.with_indifferent_access }
+
+    context 'when cluster and partition keys given' do
+      let(:options) { {
+        :counter_name   => :test_counter,
+        :value_keys     => [:param0, :param1],
+        :cluster_keys     => [:cluster, :subcluster],
+        :partition_keys => [:part, :subpart]
+      } }
+
+      # 2 разных знач в одном кластере и партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      before { values.times { counter.add(:param0 => 1, :param1 => 3, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      # дубль знач в другой партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart3) } }
+      # дубль знач в другом кластере
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster3, :part => :part1, :subpart => :subpart1) } }
+      # новое значение в новой подпартиции
+      before { values.times { counter.add(:param0 => 3, :param1 => 4, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart2) } }
+      # новое значение в новой партиции
+      before { values.times { counter.add(:param0 => 4, :param1 => 5, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part2, :subpart => :subpart1) } }
+      # новое значение в новом кластере
+      before { values.times { counter.add(:param0 => 5, :param1 => 6, :cluster => :cluster2, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      # новое значение в новом подкластере
+      before { values.times { counter.add(:param0 => 6, :param1 => 7, :cluster => :cluster1, :subcluster => :subcluster2, :part => :part1, :subpart => :subpart1) } }
+
+      context 'when no cluster given' do
+        it { expect { counter.data }.to raise_error ArgumentError }
+      end
+
+      context 'when no leaf cluster given' do
+        it { expect { counter.data(:cluster => :cluster1) }.to raise_error KeyError }
+      end
+
+      context 'when unknown cluster given' do
+        it { expect(counter.data(:cluster => :unknown_cluster, :subcluster => :subcluster)).to have(0).partitions }
+      end
+
+      context 'when no partition given' do
+        it { expect(counter.data(cluster1_subcluster1)).to have(4).rows }
+        it { expect(counter.data(cluster1_subcluster1)).to include ({'param0' => '1', 'param1' => '2'}) }
+        it { expect(counter.data(cluster1_subcluster1)).to include ({'param0' => '1', 'param1' => '3'}) }
+        it { expect(counter.data(cluster1_subcluster1)).to include ({'param0' => '3', 'param1' => '4'}) }
+        it { expect(counter.data(cluster1_subcluster1)).to include ({'param0' => '4', 'param1' => '5'}) }
+
+        it { expect(counter.data(cluster2_subcluster1)).to have(1).rows }
+        it { expect(counter.data(cluster2_subcluster1).first).to include ({'param0' => '5', 'param1' => '6'}) }
+      end
+
+      context 'when not leaf partition given' do
+        it { expect(counter.data(cluster1_subcluster1.merge(:part => :part1))).to have(3).rows }
+        it { expect(counter.data(cluster1_subcluster1.merge(:part => :part1))).to include ({'param0' => '1', 'param1' => '2'}) }
+        it { expect(counter.data(cluster1_subcluster1.merge(:part => :part1))).to include ({'param0' => '1', 'param1' => '3'}) }
+        it { expect(counter.data(cluster1_subcluster1.merge(:part => :part1))).to include ({'param0' => '3', 'param1' => '4'}) }
+      end
+
+      context 'when leaf partition given' do
+        it { expect(counter.data(cluster1_subcluster1.merge(:part => :part1, 'subpart' => 'subpart1'))).to have(2).rows }
+        it { expect(counter.data(cluster1_subcluster1.merge(:part => :part1, 'subpart' => 'subpart1'))).to include ({'param0' => '1', 'param1' => '2'}) }
+        it { expect(counter.data(cluster1_subcluster1.merge(:part => :part1, 'subpart' => 'subpart1'))).to include ({'param0' => '1', 'param1' => '3'}) }
+      end
+    end
+
+    context 'when not cluster keys given and partition keys given' do
+      let(:options) { {
+        :counter_name   => :test_counter,
+        :value_keys     => [:param0, :param1],
+        :partition_keys => [:part, :subpart]
+      } }
+
+      # 2 разных знач в одной партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :part => :part1, :subpart => :subpart1) } }
+      before { values.times { counter.add(:param0 => 1, :param1 => 3, :part => :part1, :subpart => :subpart1) } }
+      # дубль знач в другой партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :part => :part1, :subpart => :subpart3) } }
+      # новое значение в новой подпартиции
+      before { values.times { counter.add(:param0 => 3, :param1 => 4, :part => :part1, :subpart => :subpart2) } }
+      # новое значение в новой партиции
+      before { values.times { counter.add(:param0 => 4, :param1 => 5, :part => :part2, :subpart => :subpart1) } }
+
+      context 'when no cluster given' do
+        it { expect { counter.data }.to_not raise_error KeyError }
+      end
+
+      context 'when no partition given' do
+        it { expect(counter.data).to have(4).rows }
+        it { expect(counter.data).to include ({'param0' => '1', 'param1' => '2'}) }
+        it { expect(counter.data).to include ({'param0' => '1', 'param1' => '3'}) }
+        it { expect(counter.data).to include ({'param0' => '3', 'param1' => '4'}) }
+        it { expect(counter.data).to include ({'param0' => '4', 'param1' => '5'}) }
+      end
+
+      context 'when not leaf partition given' do
+        it { expect(counter.data(:part => :part1)).to have(3).rows }
+        it { expect(counter.data(:part => :part1)).to include ({'param0' => '1', 'param1' => '2'}) }
+        it { expect(counter.data(:part => :part1)).to include ({'param0' => '1', 'param1' => '3'}) }
+        it { expect(counter.data(:part => :part1)).to include ({'param0' => '3', 'param1' => '4'}) }
+      end
+
+      context 'when leaf partition given' do
+        it { expect(counter.data(:part => :part1, 'subpart' => 'subpart1')).to have(2).items }
+        it { expect(counter.data(:part => :part1, 'subpart' => 'subpart1')).to include ({'param0' => '1', 'param1' => '2'}) }
+        it { expect(counter.data(:part => :part1, 'subpart' => 'subpart1')).to include ({'param0' => '1', 'param1' => '3'}) }
+      end
+    end
+
+    context 'when cluster keys given and partition keys not given' do
+      let(:options) { {
+        :counter_name   => :test_counter,
+        :value_keys     => [:param0, :param1],
+        :cluster_keys     => [:cluster, :subcluster]
+      } }
+
+      # 2 разных знач в одном кластере
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster1) } }
+      before { values.times { counter.add(:param0 => 1, :param1 => 3, :cluster => :cluster1, :subcluster => :subcluster1) } }
+      # дубль знач в другом кластере
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster3) } }
+      # новое значение в новом кластере
+      before { values.times { counter.add(:param0 => 5, :param1 => 6, :cluster => :cluster2, :subcluster => :subcluster1) } }
+      # новое значение в новом подкластере
+      before { values.times { counter.add(:param0 => 6, :param1 => 7, :cluster => :cluster1, :subcluster => :subcluster2) } }
+
+
+      context 'when no partition given' do
+        it { expect(counter.partitions(cluster1_subcluster1)).to have(1).partitions }
+        it { expect(counter.partitions(cluster1_subcluster1).first).to eq Hash.new }
+
+        it { expect(counter.partitions(cluster2_subcluster1)).to have(1).partitions }
+        it { expect(counter.partitions(cluster2_subcluster1).first).to eq Hash.new }
+      end
+    end
+  end
+
+  context '#delete_partitions!' do
+    let(:cluster1_subcluster1) { {:cluster => :cluster1, :subcluster => :subcluster1} }
+    let(:cluster1_subcluster2) { {:cluster => :cluster1, :subcluster => :subcluster2} }
+    let(:cluster1_subcluster3) { {:cluster => :cluster1, :subcluster => :subcluster3} }
+    let(:cluster2_subcluster1) { {:cluster => :cluster2, :subcluster => :subcluster1} }
+
+    let(:part1_subpart1) { {:part => 'part1', :subpart => 'subpart1'}.with_indifferent_access }
+    let(:part1_subpart2) { {:part => 'part1', :subpart => 'subpart2'}.with_indifferent_access }
+    let(:part2_subpart1) { {'part' => 'part2', :subpart => 'subpart1'}.with_indifferent_access }
+
+    context 'when cluster and partition keys given' do
+      let(:options) { {
+        :counter_name   => :test_counter,
+        :value_keys     => [:param0, :param1],
+        :cluster_keys     => [:cluster, :subcluster],
+        :partition_keys => [:part, :subpart]
+      } }
+
+      # 2 разных знач в одном кластере и партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      before { values.times { counter.add(:param0 => 1, :param1 => 3, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      # дубль знач в другой партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart3) } }
+      # дубль знач в другом кластере
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster3, :part => :part1, :subpart => :subpart1) } }
+      # новое значение в новой подпартиции
+      before { values.times { counter.add(:param0 => 3, :param1 => 4, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart2) } }
+      # новое значение в новой партиции
+      before { values.times { counter.add(:param0 => 4, :param1 => 5, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part2, :subpart => :subpart1) } }
+      # новое значение в новом кластере
+      before { values.times { counter.add(:param0 => 5, :param1 => 6, :cluster => :cluster2, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      # новое значение в новом подкластере
+      before { values.times { counter.add(:param0 => 6, :param1 => 7, :cluster => :cluster1, :subcluster => :subcluster2, :part => :part1, :subpart => :subpart1) } }
+
+      context 'when no cluster given' do
+        it { expect { counter.delete_partitions! }.to raise_error ArgumentError }
+      end
+
+      context 'when no leaf cluster given' do
+        it { expect { counter.delete_partitions!(:cluster => :cluster1, :part => 1) }.to raise_error KeyError }
+      end
+
+      context 'when unknown cluster given' do
+        it { expect(counter.delete_partitions!(:cluster => :unknown_cluster, :subcluster => :subcluster, :part => 1)).to_not raise_error }
+      end
+
+      context 'when no partition given' do
+        before { counter.delete_partitions!(:cluster => :cluster1, :subcluster => :subcluster1) }
+
+        it { expect(counter.data(:cluster => :cluster1, :subcluster => :subcluster1)).to be_empty }
+        it { expect(counter.partitions(:cluster => :cluster1, :subcluster => :subcluster1)).to be_empty }
+
+        it { expect(counter.partitions(cluster2_subcluster1.merge(:part => :part1))).to be_present }
+        it { expect(counter.data(cluster2_subcluster1.merge(:part => :part1))).to have(1).rows }
+        it { expect(counter.data(cluster2_subcluster1.merge(:part => :part1))).to include ({'param0' => '5', 'param1' => '6'}) }
+      end
+
+      context 'when not leaf partition given' do
+        before { counter.delete_partitions!(cluster1_subcluster1.merge(:part => :part1)) }
+
+        it { expect(counter.partitions(cluster1_subcluster1.merge(:part => :part1))).to have(0).rows }
+
+        it { expect(counter.partitions(cluster1_subcluster1.merge(:part => :part2))).to be_present }
+        it { expect(counter.data(cluster1_subcluster1.merge(:part => :part2))).to have(1).rows }
+        it { expect(counter.data(cluster1_subcluster1.merge(:part => :part2))).to include ({'param0' => '4', 'param1' => '5'}) }
+
+        it { expect(counter.partitions(cluster2_subcluster1.merge(:part => :part1))).to be_present }
+        it { expect(counter.data(cluster2_subcluster1.merge(:part => :part1))).to have(1).rows }
+        it { expect(counter.data(cluster2_subcluster1.merge(:part => :part1))).to include ({'param0' => '5', 'param1' => '6'}) }
+      end
+
+      context 'when leaf partition given' do
+        before { counter.delete_partitions!(cluster1_subcluster1.merge(:part => :part1, :subpart => :subpart1)) }
+
+        it { expect(counter.partitions(cluster1_subcluster1.merge(:part => :part1, :subpart => :subpart1))).to have(0).rows }
+
+        it { expect(counter.partitions(cluster1_subcluster1.merge(:part => :part1, :subpart => :subpart2))).to have(1).rows }
+        it { expect(counter.data(cluster1_subcluster1.merge(:part => :part1, :subpart => :subpart2))).to include ({'param0' => '3', 'param1' => '4'}) }
+      end
+    end
+  end
+
+  context '#delete_all!' do
+    let(:cluster1_subcluster1) { {:cluster => :cluster1, :subcluster => :subcluster1} }
+    let(:cluster1_subcluster2) { {:cluster => :cluster1, :subcluster => :subcluster2} }
+    let(:cluster1_subcluster3) { {:cluster => :cluster1, :subcluster => :subcluster} }
+    let(:cluster2_subcluster1) { {:cluster => :cluster2, :subcluster => :subcluster1} }
+
+    let(:part1_subpart1) { {:part => 'part1', :subpart => 'subpart1'}.with_indifferent_access }
+    let(:part1_subpart2) { {:part => 'part1', :subpart => 'subpart2'}.with_indifferent_access }
+    let(:part2_subpart1) { {'part' => 'part2', :subpart => 'subpart1'}.with_indifferent_access }
+
+    context 'when cluster and partition keys given' do
+      let(:options) { {
+        :counter_name   => :test_counter,
+        :value_keys     => [:param0, :param1],
+        :cluster_keys   => [:cluster, :subcluster],
+        :partition_keys => [:part, :subpart]
+      } }
+
+      # 2 разных знач в одном кластере и партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      before { values.times { counter.add(:param0 => 1, :param1 => 3, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      # дубль знач в другой партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart3) } }
+      # дубль знач в другом кластере
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster3, :part => :part1, :subpart => :subpart1) } }
+      # новое значение в новой подпартиции
+      before { values.times { counter.add(:param0 => 3, :param1 => 4, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart2) } }
+      # новое значение в новой партиции
+      before { values.times { counter.add(:param0 => 4, :param1 => 5, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part2, :subpart => :subpart1) } }
+      # новое значение в новом кластере
+      before { values.times { counter.add(:param0 => 5, :param1 => 6, :cluster => :cluster2, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      # новое значение в новом подкластере
+      before { values.times { counter.add(:param0 => 6, :param1 => 7, :cluster => :cluster1, :subcluster => :subcluster2, :part => :part1, :subpart => :subpart1) } }
+
+      context 'when no cluster given' do
+        it { expect { counter.delete_all! }.to raise_error ArgumentError }
+      end
+
+      context 'when no leaf cluster given' do
+        it { expect { counter.delete_all!(:cluster => :cluster1) }.to raise_error KeyError }
+      end
+
+      context 'when unknown cluster given' do
+        before { counter.delete_all!(:cluster => :unknown_cluster, :subcluster => :subcluster) }
+
+        it { expect(counter.partitions(cluster1_subcluster1)).to have(3).partitions }
+      end
+
+      context 'when unknown params given' do
+        it { expect { counter.delete_all!(:cluster1 => :cluster1) }.to raise_error KeyError }
+      end
+
+      context 'when no partition given' do
+        before { counter.delete_all!(cluster1_subcluster1) }
+
+        it { expect(counter.data(cluster1_subcluster1)).to have(0).rows }
+        it { expect(counter.data(cluster2_subcluster1)).to have(1).rows }
+        it { expect(counter.data(cluster1_subcluster2)).to have(1).rows }
+        it { expect(counter.data(cluster2_subcluster1)).to include ({'param0' => '5', 'param1' => '6'}) }
+        it { expect(counter.data(cluster1_subcluster2)).to include ({'param0' => '6', 'param1' => '7'}) }
+
+        it { expect(counter.partitions(cluster1_subcluster1)).to have(0).partitions }
+        it { expect(counter.partitions(cluster2_subcluster1)).to have(1).partitions }
+        it { expect(counter.partitions(cluster2_subcluster1)).to have(1).partitions }
+      end
+    end
+
+    context 'when cluster not given and partition keys given' do
+      let(:options) { {
+        :counter_name   => :test_counter,
+        :value_keys     => [:param0, :param1],
+        :partition_keys => [:part, :subpart]
+      } }
+
+      # 2 разных знач в одном кластере и партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      before { values.times { counter.add(:param0 => 1, :param1 => 3, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      # дубль знач в другой партиции
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart3) } }
+      # дубль знач в другом кластере
+      before { values.times { counter.add(:param0 => 1, :param1 => 2, :cluster => :cluster1, :subcluster => :subcluster3, :part => :part1, :subpart => :subpart1) } }
+      # новое значение в новой подпартиции
+      before { values.times { counter.add(:param0 => 3, :param1 => 4, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart2) } }
+      # новое значение в новой партиции
+      before { values.times { counter.add(:param0 => 4, :param1 => 5, :cluster => :cluster1, :subcluster => :subcluster1, :part => :part2, :subpart => :subpart1) } }
+      # новое значение в новом кластере
+      before { values.times { counter.add(:param0 => 5, :param1 => 6, :cluster => :cluster2, :subcluster => :subcluster1, :part => :part1, :subpart => :subpart1) } }
+      # новое значение в новом подкластере
+      before { values.times { counter.add(:param0 => 6, :param1 => 7, :cluster => :cluster1, :subcluster => :subcluster2, :part => :part1, :subpart => :subpart1) } }
+
+      context 'when no cluster given' do
+        before { counter.delete_all! }
+
+        it { expect(counter.partitions).to have(0).partitions }
+      end
+
+      context 'when unknown cluster given' do
+        before { counter.delete_all!(:cluster => :unknown_cluster, :subcluster => :subcluster) }
+
+        it { expect(counter.partitions).to have(0).partitions }
+      end
+
+      context 'when unknown params given' do
+        before { counter.delete_all!(:cluster1 => :cluster1) }
+
+        it { expect(counter.partitions).to have(0).partitions }
+      end
+    end
+  end
+end