redis_model 0.1.0.pre3

data/spec/redis_model/types/sorted_set_spec.rb

@@ -0,0 +1,303 @@
+require 'spec_helper'
+
+describe RedisModel::Types::SortedSet do
+  let(:klass) { dynamic_class(RedisModel::Base) }
+  let(:object) { klass.new }
+  let(:members) { { one: 1, two: 2, three: 3 } }
+  let(:populate) { members.each { |value, score| RedisModel::Base.connection.zadd object.key_label, score, value } }
+
+  before { klass.data_type :sorted_set }
+
+  describe '#to_a' do
+    context 'when sorted set does not exist' do
+      it { expect(object.to_a).to eq([]) }
+    end
+
+    context 'when sorted set has been populated before' do
+      before { populate }
+
+      it { expect(object.to_a.sort).to eq(members.keys.map(&:to_s).sort) }
+    end
+  end
+
+  describe '#count_range' do
+    context 'when sorted set does not exist' do
+      it { expect(object.count_range(0, 4)).to eq(0) }
+    end
+
+    context 'when sorted set has been populated before' do
+      before { populate }
+
+      it { expect(object.count_range(0, 4)).to eq(members.length) }
+    end
+  end
+
+  describe '#include?' do
+    context 'when sorted set does not exist' do
+      it { expect(object.include?(members.keys.first)).to be_false }
+    end
+
+    context 'when sorted set has been populated before' do
+      before { populate }
+
+      it { expect(object.include?(members.keys.first)).to be_true }
+      it { expect(object.include?('unknown key')).to be_false }
+    end
+  end
+
+  describe '#get_range_by_rank' do
+    context 'when sorted set does not exist' do
+      it { expect(object.get_range_by_rank(0, 1)).to eq([]) }
+    end
+
+    context 'when sorted set has been populated before' do
+      before { populate }
+
+      it { expect(object.get_range_by_rank(0, 0)).to eq(members.sort_by(&:last).reverse.slice(0, 1).map(&:first).map(&:to_s)) }
+      it { expect(object.get_range_by_rank(0, 1)).to eq(members.sort_by(&:last).reverse.slice(0, 2).map(&:first).map(&:to_s)) }
+      it { expect(object.get_range_by_rank(0, 2)).to eq(members.sort_by(&:last).reverse.slice(0, 3).map(&:first).map(&:to_s)) }
+    end
+  end
+
+  describe '#get_range_by_reverse_rank' do
+    context 'when sorted set does not exist' do
+      it { expect(object.get_range_by_reverse_rank(0, 1)).to eq([]) }
+    end
+
+    context 'when sorted set has been populated before' do
+      before { populate }
+
+      it { expect(object.get_range_by_reverse_rank(0, 0)).to eq(members.sort_by(&:last).slice(0, 1).map(&:first).map(&:to_s)) }
+      it { expect(object.get_range_by_reverse_rank(0, 1)).to eq(members.sort_by(&:last).slice(0, 2).map(&:first).map(&:to_s)) }
+      it { expect(object.get_range_by_reverse_rank(0, 2)).to eq(members.sort_by(&:last).slice(0, 3).map(&:first).map(&:to_s)) }
+    end
+  end
+
+  describe '#get_rank' do
+    context 'when sorted set does not exist' do
+      it { expect(object.get_rank(members.keys.first)).to be_nil }
+    end
+
+    context 'when sorted set has been populated before' do
+      before { populate }
+
+      it do
+        members.each do |key, value|
+          expect(object.get_rank(key)).to eq(members.sort_by(&:last).reverse.map(&:first).index(key))
+        end
+      end
+
+      it { expect(object.get_rank('unknown')).to be_nil }
+    end
+  end
+
+  describe '#score' do
+    context 'when sorted set does not exist' do
+      it { expect(object.score(members.keys.first)).to be_nil }
+    end
+
+    context 'when sorted set has been populated before' do
+      before { populate }
+
+      it do
+        members.each do |key, value|
+          expect(object.score(key)).to eq(members[key])
+        end
+      end
+
+      it { expect(object.score('unknown')).to be_nil }
+    end
+  end
+
+  describe '#count' do
+    context 'when sorted set does not exist' do
+      it { expect(object.count).to eq(0) }
+    end
+
+    context 'when sorted set has been populated before' do
+      before { populate }
+
+      it { expect(object.count).to eq(members.count) }
+    end
+  end
+
+  describe '#get_range' do
+    context 'when sorted set does not exist' do
+      it { expect(object.get_range(0, 4)).to eq([]) }
+    end
+
+    context 'when sorted set has been populated before' do
+      before { populate }
+
+      it { expect(object.get_range(members.values.min, members.values.max)).to eq(members.reject { |k, v| [members.values.min, members.values.max].include?(v) }.keys.map(&:to_s)) }
+      it { expect(object.get_range(members.values.min, members.values.max, include_boundaries: true)).to eq(members.sort_by(&:last).reverse.map(&:first).map(&:to_s)) }
+    end
+  end
+
+  describe '#put' do
+    it { expect { object.put(0, 'zero') }.to change { object.count }.by(1) }
+  end
+
+  describe '#remove' do
+    context 'when sorted set does not exist' do
+      it { expect { object.remove('one') }.not_to change { object.count } }
+    end
+
+    context 'when sorted set has been populated before' do
+      before { populate }
+
+      it { expect { object.remove(members.keys.first) }.to change { object.count } }
+      it { expect { object.remove('unknown') }.not_to change { object.count } }
+    end
+  end
+
+  describe '#remove_range' do
+    context 'when sorted set does not exist' do
+      it { expect { object.remove_range }.not_to change { object.count } }
+    end
+
+    context 'when sorted set has been populated before' do
+      before { populate }
+
+      it { expect { object.remove_range }.to change { object.count }.to(0) }
+      it { expect { object.remove_range(members.values.min, members.values.max) }.to change { object.count }.to(0) }
+      it { expect { object.remove_range(members.values.min + 1, members.values.max) }.to change { object.count }.to(1) }
+    end
+  end
+
+  describe '#duplicate' do
+    context 'when sorted set does not exist' do
+      it { expect { object.duplicate('new') }.not_to change { RedisModel::Base.connection.keys } }
+    end
+
+    context 'when sorted set has been populated before' do
+      before { populate }
+
+      it { expect { object.duplicate('new') }.to change { RedisModel::Base.connection.keys } }
+    end
+  end
+
+  describe '#intersect' do
+    before { populate }
+
+    context 'when operand is a sorted set' do
+      let(:operand_klass) { dynamic_class(RedisModel::Base) }
+      let(:operand) { operand_klass.new }
+      let(:operand_members) { { three: 3, four: 4, five: 5 } }
+
+      before { operand_klass.data_type :sorted_set }
+      before { operand_members.each { |key, value| operand.put(value, key) } }
+
+      context 'when block is not given' do
+        it { expect(object.intersect(operand)).to be_kind_of(RedisModel::Intersected) }
+        it { expect(object.intersect(operand).key_label).to be_include(object.key_label) }
+        it { expect(object.intersect(operand).key_label).to be_include(operand.key_label) }
+
+        context 'when seed is given' do
+          let(:seed) { 123 }
+
+          it { expect(object.intersect(operand, seed: seed).key_label).to be_include(seed.to_s) }
+        end
+
+        context 'when generated' do
+          before { object.intersect(operand).generate }
+
+          it { expect(object.intersect(operand)).to be_exists }
+          it { expect(object.intersect(operand).to_a).to eq((members.keys & operand_members.keys).map(&:to_s)) }
+        end
+      end
+
+      context 'when block is given' do
+        it 'yields an instance of RedisModel::Intersected' do
+          object.intersect(operand) do |intersected|
+            expect(intersected).to be_kind_of(RedisModel::Intersected)
+          end
+        end
+
+        it 'returns evaluation result of block' do
+          expect(object.intersect(operand) do |intersected|
+            intersected.to_a
+          end).to eq((members.keys & operand_members.keys).map(&:to_s))
+        end
+
+        it 'the yielded instance has key_label which starts with caller\'s key_label' do
+          object.intersect(operand) do |intersected|
+            expect(intersected.key_label).to be_include(object.key_label)
+            expect(intersected.key_label).to be_include(operand.key_label)
+          end
+        end
+
+        it 'clears up intersected set' do
+          key_label = nil
+
+          object.intersect(operand) do |intersected|
+            key_label = intersected.key_label
+          end
+
+          expect(RedisModel::Base.connection.exists(key_label)).to be_false
+        end
+
+        context 'when seed is given' do
+          let(:seed) { 123 }
+
+          it 'adds seed string to key_label' do
+            key_label = nil
+
+            object.intersect(operand, seed: seed) do |intersected|
+              key_label = intersected.key_label
+            end
+
+            expect(key_label).to be_include(seed.to_s)
+          end
+        end
+      end
+    end
+
+    context 'when operand is a set' do
+      let(:operand_klass) { dynamic_class(RedisModel::Base) }
+      let(:operand) { operand_klass.new }
+      let(:operand_members) { [:three, :four, :five] }
+
+      before { operand_klass.data_type :set }
+      before { operand_members.each { |value| operand << value } }
+
+      context 'when block is not given' do
+        it { expect(object.intersect(operand)).to be_kind_of(RedisModel::Intersected) }
+        it { expect(object.intersect(operand).key_label).to be_include(object.key_label) }
+        it { expect(object.intersect(operand).key_label).to be_include(operand.key_label) }
+
+        context 'when generated' do
+          before { object.intersect(operand).generate }
+
+          it { expect(object.intersect(operand)).to be_exists }
+          it { expect(object.intersect(operand).to_a).to eq((members.keys & operand_members).map(&:to_s)) }
+        end
+      end
+
+      context 'when block is given' do
+        it 'yields an instance of RedisModel::Intersected' do
+          object.intersect(operand) do |intersected|
+            expect(intersected).to be_kind_of(RedisModel::Intersected)
+          end
+        end
+
+        it 'the yielded instance has key_label which starts with caller\'s key_label' do
+          object.intersect(operand) do |intersected|
+            expect(intersected.key_label).to be_include(object.key_label)
+            expect(intersected.key_label).to be_include(operand.key_label)
+          end
+        end
+
+        it 'clears up intersected set' do
+          key_label = nil
+
+          object.intersect(operand) do |intersected|
+            key_label = intersected.key_label
+          end
+
+          expect(RedisModel::Base.connection.exists(key_label)).to be_false
+        end
+      end
+    end
+  end
+end

data/spec/redis_model/types/string_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe RedisModel::Types::String do
+  let(:klass) { dynamic_class(RedisModel::Base) }
+  let(:object) { klass.new }
+
+  before { klass.data_type :string }
+
+  describe '#get' do
+    context 'when no value was set before' do
+      it { expect(object.get).to be_nil }
+    end
+
+    context 'when value was set before' do
+      let(:value) { 'hi' }
+
+      before { RedisModel::Base.connection.set(object.key_label, value) }
+
+      it { expect(object.get).to eq(value) }
+    end
+  end
+
+  describe '#set' do
+    context 'when value was set before' do
+      it { expect { object.set('value') }.to change { RedisModel::Base.connection.get object.key_label } }
+    end
+  end
+end

data/spec/redis_model/types/timestamp_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe RedisModel::Types::Timestamp do
+  let(:klass) { dynamic_class(RedisModel::Base) }
+  let(:object) { klass.new }
+
+  before { klass.data_type :timestamp }
+
+  describe '#to_time' do
+    context 'when no value was set before' do
+      it { expect(object.to_time).to be_nil }
+    end
+
+    context 'when value was set before' do
+      let(:value) { DateTime.current }
+
+      before { RedisModel::Base.connection.set(object.key_label, value) }
+
+      it { expect(object.to_time.to_i).to eq(value.to_i) }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'redis_model'
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+
+  config.before(:each) do
+    RedisModel::Base.connection.flushall
+  end
+end

data/spec/support/dynamic_class.rb

@@ -0,0 +1,5 @@
+def dynamic_class(parent, name = 'Klass')
+  random_string = SecureRandom.base64(4).tr('+/=lIO0', 'pqrsxyz')
+
+  Class.new(parent).tap { |k| Object.const_set("#{name}#{random_string}", k) }
+end

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: redis_model
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre3
+platform: ruby
+authors:
+- Inbeom Hwang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kaminari
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: RedisModel provides various types of interfaces to handle values on Redis
+email:
+- hwanginbeom@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/redis_model.rb
+- lib/redis_model/adapters/paperclip.rb
+- lib/redis_model/attribute.rb
+- lib/redis_model/base.rb
+- lib/redis_model/belonged_to.rb
+- lib/redis_model/class_attribute.rb
+- lib/redis_model/configurations.rb
+- lib/redis_model/helpers/sorted_set_paginator.rb
+- lib/redis_model/intersected.rb
+- lib/redis_model/schema.rb
+- lib/redis_model/types/base.rb
+- lib/redis_model/types/base_value.rb
+- lib/redis_model/types/counter.rb
+- lib/redis_model/types/float.rb
+- lib/redis_model/types/hash.rb
+- lib/redis_model/types/integer.rb
+- lib/redis_model/types/list.rb
+- lib/redis_model/types/set.rb
+- lib/redis_model/types/sorted_set.rb
+- lib/redis_model/types/string.rb
+- lib/redis_model/types/timestamp.rb
+- lib/redis_model/version.rb
+- redis_model.gemspec
+- spec/redis_model/attribute_spec.rb
+- spec/redis_model/base_spec.rb
+- spec/redis_model/class_attribute_spec.rb
+- spec/redis_model/helpers/sorted_set_paginator_spec.rb
+- spec/redis_model/schema_spec.rb
+- spec/redis_model/types/base_spec.rb
+- spec/redis_model/types/counter_spec.rb
+- spec/redis_model/types/float_spec.rb
+- spec/redis_model/types/hash_spec.rb
+- spec/redis_model/types/integer_spec.rb
+- spec/redis_model/types/list_spec.rb
+- spec/redis_model/types/set_spec.rb
+- spec/redis_model/types/sorted_set_spec.rb
+- spec/redis_model/types/string_spec.rb
+- spec/redis_model/types/timestamp_spec.rb
+- spec/spec_helper.rb
+- spec/support/dynamic_class.rb
+homepage: http://gitlab.ultracaption.net/inbeom/redis_model
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Interfaces for Redis values.
+test_files:
+- spec/redis_model/attribute_spec.rb
+- spec/redis_model/base_spec.rb
+- spec/redis_model/class_attribute_spec.rb
+- spec/redis_model/helpers/sorted_set_paginator_spec.rb
+- spec/redis_model/schema_spec.rb
+- spec/redis_model/types/base_spec.rb
+- spec/redis_model/types/counter_spec.rb
+- spec/redis_model/types/float_spec.rb
+- spec/redis_model/types/hash_spec.rb
+- spec/redis_model/types/integer_spec.rb
+- spec/redis_model/types/list_spec.rb
+- spec/redis_model/types/set_spec.rb
+- spec/redis_model/types/sorted_set_spec.rb
+- spec/redis_model/types/string_spec.rb
+- spec/redis_model/types/timestamp_spec.rb
+- spec/spec_helper.rb
+- spec/support/dynamic_class.rb