redis_model 0.1.0.pre3

data/spec/redis_model/attribute_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+class TestModel
+  attr_accessor :id, :custom
+
+  def initialize(id, custom = nil)
+    @id = id
+    @custom = custom
+  end
+end
+
+describe RedisModel::Attribute do
+  let(:parent_klass) { dynamic_class(TestModel) }
+
+  before { parent_klass.send(:include, RedisModel::Attribute) }
+
+  describe '.redis_model_attribute' do
+    let(:attribute_name) { :my_counter }
+    let(:attribute_type) { :counter }
+    let(:test_id) { 'test' }
+
+    it { expect { parent_klass.redis_model_attribute attribute_name, attribute_type }.to change { parent_klass.new(test_id).respond_to?(attribute_name) } }
+    it { expect { parent_klass.redis_model_attribute attribute_name, attribute_type }.to change { parent_klass.new(test_id).respond_to?(:"#{attribute_name}=") } }
+
+    context 'when belonged_to klass is defined' do
+      let(:key_label) { parent_klass.new(test_id).send(attribute_name).key_label }
+
+      before { parent_klass.redis_model_attribute attribute_name, attribute_type }
+
+      it { expect(parent_klass.new(test_id).send(attribute_name)).to be_kind_of(RedisModel::BelongedTo) }
+      it { expect(parent_klass.new(test_id).send(attribute_name).class.included_modules).to include(RedisModel::Types::Counter) }
+      it { expect(key_label).to end_with(test_id) }
+      it { expect(key_label).to include(parent_klass.to_s.underscore) }
+    end
+
+    context 'when parent klass is inherited' do
+      let(:child_klass) { dynamic_class(parent_klass) }
+
+      it { expect { parent_klass.redis_model_attribute attribute_name, attribute_type }.to change { child_klass.new(test_id).respond_to?(attribute_name) } }
+      it { expect { parent_klass.redis_model_attribute attribute_name, attribute_type }.to change { child_klass.new(test_id).respond_to?(:"#{attribute_name}=") } }
+
+      context 'when belonged_to klass is defined' do
+        before { parent_klass.redis_model_attribute attribute_name, attribute_type }
+
+        it { expect(parent_klass.new(test_id).send(attribute_name).class).to eq(child_klass.new(test_id).send(attribute_name).class) }
+        it { expect(parent_klass.new(test_id).send(attribute_name).key_label).to eq(child_klass.new(test_id).send(attribute_name).key_label) }
+      end
+    end
+
+    context 'when foreign_key option is specified' do
+      let(:custom_id) { 'customid' }
+      let(:key_label) { parent_klass.new(test_id, custom_id).send(attribute_name).key_label }
+
+      before { parent_klass.redis_model_attribute attribute_name, attribute_type, foreign_key: :custom }
+
+      it { expect(key_label).to end_with(custom_id) }
+      it { expect(key_label).to include(parent_klass.to_s.underscore) }
+      it { expect(key_label).to end_with(custom_id) }
+      it { expect(key_label).not_to end_with(test_id) }
+    end
+
+    describe '.redis_model_attributes' do
+      it { expect(parent_klass.redis_model_attributes).to be_kind_of(RedisModel::Attribute::DefinitionHelper) }
+      it { expect { parent_klass.redis_model_attributes { counter :my_counter } }.to change { parent_klass.new(test_id).methods } }
+    end
+  end
+
+  describe RedisModel::Attribute::DefinitionHelper do
+    let(:parent_klass) { dynamic_class(TestModel) }
+    let(:definition_helper) { RedisModel::Attribute::DefinitionHelper.new parent_klass, {} }
+
+    it { expect(definition_helper).to respond_to(:counter) }
+    it { expect(definition_helper).to respond_to(:set) }
+    it { expect(definition_helper).to respond_to(:sorted_set) }
+    it { expect { definition_helper.counter :my_counter }.to change { parent_klass.new('test').methods } }
+  end
+end

data/spec/redis_model/base_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe RedisModel::Base do
+  let(:klass) { dynamic_class(RedisModel::Base) }
+  let(:another_klass) { dynamic_class(RedisModel::Base, 'Another') }
+
+  describe '.data_type' do
+    it { expect { klass.data_type(:value) }.to change { RedisModel::Schema.collection.keys }.by([klass]) }
+    it { expect { klass.data_type(:string) }.to change { RedisModel::Schema.collection[klass] }.from(nil) }
+    it { expect { klass.data_type(:string) }.to change { klass.included_modules.include?(RedisModel::Types::String) }.from(false).to(true) }
+
+    context 'when child class tries to redefine data type' do
+      let(:child_klass) { dynamic_class(klass, 'Child') }
+
+      before { klass.data_type(:value) }
+
+      it { expect { child_klass.data_type(:value) }.to raise_error(RedisModel::Schema::DuplicateDefinition) }
+    end
+
+    context 'when another class defines its data type' do
+      before { klass.data_type(:value) }
+
+      it { expect { another_klass.data_type(:string) }.not_to change { RedisModel::Schema.find(klass) } }
+    end
+  end
+
+  describe '.connection' do
+    before { klass.data_type :counter }
+    before { another_klass.data_type :string }
+
+    it { expect(klass.connection).to be_kind_of(Redis) }
+    it { expect(klass.connection).to eq(another_klass.connection) }
+  end
+end

data/spec/redis_model/class_attribute_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'redis_model/class_attribute'
+
+class TestClass
+  include RedisModel::ClassAttribute
+
+  redis_class_attribute :something, :set
+end
+
+describe RedisModel::ClassAttribute do
+  context '.redis_class_attribue' do
+    it { expect(TestClass).to be_respond_to(:something) }
+    it { expect(TestClass).to be_respond_to(:something=) }
+    it { expect(TestClass.something).to be_kind_of(RedisModel::Base) }
+  end
+end

data/spec/redis_model/helpers/sorted_set_paginator_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'redis_model/helpers/sorted_set_paginator'
+
+describe RedisModel::Helpers::SortedSetPaginator do
+  let(:klass) { dynamic_class(RedisModel::Base) }
+  let(:sorted_set) { klass.new }
+  let(:paginator) { RedisModel::Helpers::SortedSetPaginator.new(sorted_set) }
+
+  before { klass.data_type :sorted_set }
+  before { (1..10).each { |number| sorted_set.put(number, number) } }
+
+  describe '#page' do
+    it { expect(paginator.per(1).page(1).map(&:to_i)).to eq([10]) }
+    it { expect(paginator.per(1).page(2).map(&:to_i)).to eq([9]) }
+    it { expect(paginator.per(1).page(10).map(&:to_i)).to eq([1]) }
+  end
+
+  describe '#per' do
+    it { expect(paginator.per(2).page(1).map(&:to_i)).to eq([10, 9]) }
+    it { expect(paginator.per(3).page(1).map(&:to_i)).to eq([10, 9, 8]) }
+    it { expect(paginator.per(4).page(1).map(&:to_i)).to eq([10, 9, 8, 7]) }
+  end
+
+  describe '#max_id' do
+    it { expect(paginator.max_id(3).map(&:to_i)).to eq([2, 1]) }
+    it { expect(paginator.max_id(4).map(&:to_i)).to eq([3, 2, 1]) }
+  end
+
+  describe '#since_id' do
+    it { expect(paginator.since_id(8).map(&:to_i)).to eq([10, 9]) }
+    it { expect(paginator.since_id(9).map(&:to_i)).to eq([10]) }
+  end
+end

data/spec/redis_model/schema_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'redis_model/schema'
+
+describe RedisModel::Schema do
+  let(:random_string) { SecureRandom.base64(4).tr('+/=lIO0', 'pqrsxyz') }
+
+  describe '.collection' do
+    it { expect(RedisModel::Schema.collection).to be_kind_of(Hash) }
+  end
+
+  describe '.find' do
+    let(:parent_klass) { Class.new }
+    let(:child_klass) { Class.new parent_klass }
+
+    before { RedisModel::Schema.collection.clear }
+
+    context 'when there is no entry of direct ancestor' do
+      it { expect(RedisModel::Schema.find(parent_klass)).to be_nil }
+      it { expect(RedisModel::Schema.find(child_klass)).to be_nil }
+    end
+
+    context 'when collection is populated' do
+      let(:value) { 1234 }
+
+      before { RedisModel::Schema.collection[child_klass] = value }
+
+      it { expect(RedisModel::Schema.find(child_klass)).to eq(value) }
+      it { expect(RedisModel::Schema.find(parent_klass)).to be_nil }
+    end
+
+    context 'when collection is populated by both' do
+      let(:parent_value) { 1234 }
+      let(:child_value) { 4321 }
+
+      before { RedisModel::Schema.collection[parent_klass] = parent_value }
+      before { RedisModel::Schema.collection[child_klass] = child_value }
+
+      it { expect(RedisModel::Schema.find(parent_klass)).to eq(parent_value) }
+      it { expect(RedisModel::Schema.find(child_klass)).to eq(child_value) }
+    end
+  end
+
+  describe '.register' do
+    let(:parent_klass) { Class.new.tap { |k| Object.const_set("Parent#{random_string}", k) } }
+    let(:child_klass) { Class.new parent_klass.tap { |k| Object.const_set("Child#{random_string}", k) } }
+
+    before { RedisModel::Schema.collection.clear }
+
+    context 'when data_type is invalid' do
+      it { expect { RedisModel::Schema.register(parent_klass, data_type: :nothing) }.to raise_error(RedisModel::Schema::UnknownType) }
+    end
+
+    context 'when data_type is valid' do
+      it { expect { RedisModel::Schema.register(parent_klass, data_type: :string) }.not_to raise_error }
+      it { expect(RedisModel::Schema.register(parent_klass, data_type: :string)).to eq(RedisModel::Types::String) }
+    end
+  end
+
+  describe '#initialize' do
+    context 'when invalid data_type key is given' do
+      it { expect { RedisModel::Schema.new(data_type: :something_i_dont_know) }.to raise_error(RedisModel::Schema::UnknownType) }
+    end
+
+    context 'when valid data_type key is given' do
+      let(:klass) { Class.new.tap { |k| Object.const_set("Parent#{random_string}", k) } }
+      let(:data_type) { :string }
+      let(:schema) { RedisModel::Schema.new(data_type: data_type, klass: klass) }
+
+      it { expect { schema }.not_to raise_error }
+      it { expect(schema.klass).to eq(klass) }
+      it { expect(schema.data_type).to eq(data_type) }
+    end
+  end
+
+  describe '#custom_key_label' do
+    let(:string_child_klass) { Class.new(String).tap { |k| Object.const_set("String#{random_string}", k) } }
+    let(:schema) { RedisModel::Schema.new data_type: :string, klass: string_child_klass }
+    let(:object) { string_child_klass.new('test') }
+
+    context 'when block is given' do
+      it { expect { schema.custom_key_label { |o| o.reverse } }.not_to raise_error }
+      it { expect { schema.custom_key_label { |o| o.reverse } }.to change { schema.key_label(object).end_with?(':tset') } }
+    end
+
+    context 'when method is given' do
+      it { expect { schema.custom_key_label(&:reverse) }.not_to raise_error }
+      it { expect { schema.custom_key_label(&:reverse) }.to change { schema.key_label(object).end_with?(':tset') } }
+    end
+  end
+
+  describe '#key_label' do
+    let(:klass) { Class.new.tap { |k| Object.const_set("Klass#{random_string}", k) } }
+    let(:schema) { RedisModel::Schema.new klass: klass, data_type: :string }
+    let(:object) { klass.new }
+    let(:app_name) { nil }
+
+    before { RedisModel::Configurations.instance.app_name = app_name }
+
+    context 'when no custom key labels and app name present' do
+      it { expect(schema.key_label(object)).to include(klass.name.underscore) }
+    end
+
+    context 'when custom key label presents' do
+      let(:label_text) { 'test' }
+      before { schema.custom_key_label { |o| label_text } }
+
+      it { expect(schema.key_label(object)).to include(klass.name.underscore) }
+      it { expect(schema.key_label(object)).to include(label_text) }
+    end
+
+    context 'when app name presents' do
+      let(:app_name) { 'app' }
+
+      it { expect(schema.key_label(object)).to include(klass.name.underscore) }
+      it { expect(schema.key_label(object)).to include(app_name) }
+    end
+  end
+end

data/spec/redis_model/types/base_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe RedisModel::Types::Base do
+  let(:klass) { dynamic_class(RedisModel::Base) }
+  let(:object) { klass.new }
+
+  before { RedisModel::Schema.register(klass, data_type: :string) }
+  before { klass.send(:include, RedisModel::Types::Base) }
+
+  describe '#exists?' do
+    it { expect(object.exists?).to be_false }
+    it { expect { RedisModel::Base.connection.set(object.key_label, 'value') }.to change { object.exists? } }
+  end
+
+  describe '#del' do
+    context 'when object exists' do
+      before { RedisModel::Base.connection.set(object.key_label, 'value') }
+
+      it { expect { object.del }.to change { object.exists? } }
+      it { expect(object.del).to eq(1) }
+    end
+
+    context 'when object does not exist' do
+      it { expect { object.del }.not_to change { object.exists? } }
+      it { expect(object.del).to eq(0) }
+    end
+  end
+end

data/spec/redis_model/types/counter_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe RedisModel::Types::Counter do
+  let(:klass) { dynamic_class(RedisModel::Base) }
+  let(:object) { klass.new }
+
+  before { klass.data_type :counter }
+
+  describe '#incr' do
+    it { expect { object.incr }.to change { object.to_i }.from(0).to(1) }
+    it { expect(object.incr).to eq(1) }
+
+    context 'when argument is given' do
+      let(:by) { 3 }
+
+      it { expect { object.incr(by) }.to change { object.to_i }.from(0).to(by) }
+      it { expect(object.incr(by)).to eq(by) }
+    end
+  end
+
+  describe '#to_i' do
+    it { expect(object.to_i).to eq(0) }
+
+    context 'when value was set previously' do
+      let(:value) { 3 }
+
+      before { RedisModel::Base.connection.set(object.key_label, value) }
+
+      it { expect(object.to_i).to eq(value) }
+    end
+  end
+end

data/spec/redis_model/types/float_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe RedisModel::Types::Float do
+  let(:klass) { dynamic_class(RedisModel::Base) }
+  let(:object) { klass.new }
+
+  before { klass.data_type :float }
+
+  describe '#to_f' do
+      it { expect(object.to_f).to be_nil }
+
+    context 'when value was set before' do
+      let(:value) { 1.23 }
+
+      before { object.set 1.23 }
+
+      it { expect(object.to_f).to eq(1.23) }
+    end
+  end
+end

data/spec/redis_model/types/hash_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe RedisModel::Types::Hash do
+  let(:klass) { dynamic_class(RedisModel::Base) }
+  let(:object) { klass.new }
+
+  before { klass.data_type :hash }
+
+  describe '#[]=' do
+    let(:key) { :some_key }
+    let(:value) { 'hello world' }
+
+    it { expect(object.[]=(key, value)).to eq(value) }
+  end
+
+  describe '#[]' do
+    let(:key) { :some_key }
+
+    context 'when value was not set before' do
+      it { expect(object[key]).to be_nil }
+    end
+
+    context 'when value was set before' do
+      let(:value) { 'hello world' }
+
+      before { object[key] = value }
+
+      it { expect(object[key]).to eq(value) }
+    end
+  end
+
+  describe '#incr' do
+    let(:key) { :some_key }
+
+    context 'when key does not exist before' do
+      it { expect(object.incr(key)).to eq(1) }
+      it { expect { object.incr(key) }.to change { object[key] }.from(nil).to(1.to_s) }
+    end
+
+    context 'when amount is given' do
+      let(:by) { 3 }
+
+      it { expect(object.incr(key, by)).to eq(by) }
+      it { expect { object.incr(key, by) }.to change { object[key] }.from(nil).to(by.to_s) }
+    end
+
+    context 'when key was set before' do
+      let(:initial) { 2 }
+
+      before { object[key] = initial }
+
+      it { expect { object.incr(key) }.to change { object[key] }.from(initial.to_s).to((initial + 1).to_s) }
+    end
+  end
+end

data/spec/redis_model/types/integer_spec.rb

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

data/spec/redis_model/types/list_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe RedisModel::Types::List do
+  let(:klass) { dynamic_class(RedisModel::Base) }
+  let(:object) { klass.new }
+
+  before { klass.data_type :list }
+
+  describe '#to_a' do
+    context 'when list does not exist' do
+      it { expect(object.to_a).to eq([]) }
+    end
+
+    context 'when list has been populated before' do
+      let(:elements) { ['testelement1', 'testelement2'] }
+
+      before { elements.each { |element| RedisModel::Base.connection.rpush(object.key_label, element) } }
+
+      it { expect(object.to_a).to eq(elements) }
+    end
+  end
+
+  describe '#count' do
+    context 'when list does not exist' do
+      it { expect(object.count).to eq(0) }
+    end
+
+    context 'when list has been populated before' do
+      let(:elements) { ['testelement1', 'testelement2'] }
+
+      before { elements.each { |element| RedisModel::Base.connection.rpush object.key_label, element } }
+
+      it { expect(object.count).to eq(elements.length) }
+    end
+  end
+
+  describe '#[]' do
+    context 'when list does not exist' do
+      it { expect(object[1]).to be_nil }
+    end
+
+    context 'when list has been populated before' do
+      let(:elements) { ['testelement1', 'testelement2'] }
+
+      before { elements.each { |element| RedisModel::Base.connection.rpush object.key_label, element } }
+
+      it { expect(object[0]).to eq(elements[0]) }
+      it { expect(object[1]).to eq(elements[1]) }
+    end
+  end
+
+  describe '#<<' do
+    it { expect { object << 1 }.to change { object.count }.by(1) }
+  end
+end

data/spec/redis_model/types/set_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe RedisModel::Types::Set do
+  let(:klass) { dynamic_class(RedisModel::Base) }
+  let(:object) { klass.new }
+
+  before { klass.data_type :set }
+
+  describe '#to_a' do
+    context 'when set does not exist' do
+      it { expect(object.to_a).to eq([]) }
+    end
+
+    context 'when set has been populated before' do
+      let(:elements) { ['testelement1', 'testelement2'] }
+
+      before { elements.each { |element| RedisModel::Base.connection.sadd(object.key_label, element) } }
+
+      it { expect(object.to_a.sort).to eq(elements.sort) }
+    end
+  end
+
+  describe '#count' do
+    context 'when set does not exist' do
+      it { expect(object.count).to eq(0) }
+    end
+
+    context 'when set has been populated before' do
+      let(:elements) { ['testelement1', 'testelement2'] }
+
+      before { elements.each { |element| RedisModel::Base.connection.sadd(object.key_label, element) } }
+
+      it { expect(object.count).to eq(elements.count) }
+    end
+  end
+
+  describe '#<<' do
+    it { expect { object << 1 }.to change { object.count }.by(1) }
+  end
+
+  describe '#remove' do
+    let(:elements) { ['testelement1', 'testelement2'] }
+
+    before { elements.each { |element| RedisModel::Base.connection.sadd(object.key_label, element) } }
+
+    context 'when removing existing element' do
+      it { expect { object.remove(elements.first) }.to change { object.count }.by(-1) }
+    end
+
+    context 'when removing non-existent element' do
+      it { expect { object.remove('nonexistent') }.not_to change { object.count } }
+    end
+  end
+
+  describe '#pick' do
+    let(:elements) { ['testelement1', 'testelement2'] }
+
+    before { elements.each { |element| RedisModel::Base.connection.sadd(object.key_label, element) } }
+
+    it { expect(object.pick(5).all? { |e| elements.include?(e) }).to be_true }
+  end
+end