active_redis 0.0.5 → 0.0.7

data/lib/active_redis/railtie.rb

@@ -1,12 +1,14 @@
 require 'active_redis/adapters/basic_adapter'
+require 'active_redis/logs/console_log'
 
 module ActiveRedis
   class Railtie < Rails::Railtie
     config.after_initialize do
       ActiveRedis.connection = ActiveRedis::Connection.new(
-      	ActiveRedis.config.connection_options || {},
-      	ActiveRedis.config.adapter || ActiveRedis::Adapters::BasicAdapter
+        ActiveRedis.config.connection_options || {},
+        ActiveRedis.config.adapter || ActiveRedis::Adapters::BasicAdapter
       )
+      ActiveRedis.log = (ActiveRedis.config.log || ActiveRedis::Logs::ConsoleLog).new
     end
   end
 end

data/lib/active_redis/relation.rb

@@ -0,0 +1,18 @@
+module ActiveRedis
+  autoload :QueryChainer,   'active_redis/query_chainer'
+  module Relation
+
+    %w{where order limit top}.each do |method|
+      class_eval <<-CODE
+        def #{method}(options = {})
+          if self.class.name == "ActiveRedis::QueryChainer"
+            self.apply_#{method}(options)
+          else
+            QueryChainer.new(self).apply_#{method}(options)
+          end
+        end
+      CODE
+    end
+
+  end
+end

data/lib/active_redis/version.rb

@@ -1,3 +1,3 @@
 module ActiveRedis
-  VERSION = "0.0.5"
+  VERSION = "0.0.7"
 end

data/specs/associations_spec.rb

@@ -0,0 +1,94 @@
+require File.dirname(File.realdirpath(__FILE__)) + '/test_helper.rb'
+require 'active_redis/associations'
+require 'active_redis/constants'
+require 'active_redis/errors'
+
+module ActiveRedis
+  module Associations
+    class SomeAssociation
+      def initialize(name, target);end
+    end
+  end
+end
+
+TestObject.class_eval do
+  def save;end
+end
+
+describe ActiveRedis::Associations do
+
+  subject { TestObject.new }
+
+  before do
+    TestObject.send :include, ActiveRedis::Associations
+  end
+
+  it "is has associations attribute" do
+    TestObject.must_respond_to :associations
+    TestObject.must_respond_to :associations=
+  end
+
+  describe "class methods" do
+
+    describe "#association" do
+
+      describe "when al least one association registered" do
+
+        let(:some_assoc) { mock() }
+
+        before do
+          TestObject.associations = {assoc: some_assoc}
+        end
+
+        it "is return registered association by name" do
+          TestObject.association(:assoc).must_be_same_as some_assoc
+        end
+
+      end
+
+      describe "when try to fetch unregistered association" do
+
+        before do
+          TestObject.associations = {}
+        end
+
+        it "is raise UnregisteredAssociationError" do
+          lambda{
+            TestObject.association(:assoc)
+          }.must_raise(ActiveRedis::UnregisteredAssociationError)
+        end
+
+      end
+
+    end
+
+    ActiveRedis::Constants::ASSOCIATIONS.each do |assoc|
+      describe "##{assoc}" do
+
+        it "is register #{assoc} association with name" do
+          TestObject.expects(:register_association).with(:object, assoc.to_sym, {}).returns true
+          TestObject.send assoc, :object
+        end
+
+      end
+    end
+
+    describe "private methods" do
+
+      describe "#register_association" do
+
+        let(:assoc) { mock() }
+
+        it "is create certain class by assoc name" do
+          ActiveRedis::Associations::SomeAssociation.expects(:new).with(:object, TestObject, {}).returns assoc
+          TestObject.send :register_association, :object, :some, {}
+          TestObject.associations.must_be :has_key?, :object
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/specs/attributes_spec.rb

@@ -0,0 +1,221 @@
+require File.dirname(File.realdirpath(__FILE__)) + '/test_helper.rb'
+require 'active_redis/attributes'
+require 'active_redis/constants'
+require 'active_redis/errors'
+
+module ActiveRedis
+  module Attributes
+    class SomeAttribute
+      def load(value);end
+      def dump(value);end
+    end
+  end
+end
+
+describe ActiveRedis::Attributes do
+
+  subject { TestObject.new }
+
+  before do
+    TestObject.send :include, ActiveRedis::Attributes
+  end
+
+  describe "instance methods" do
+
+    describe "#attributes=" do
+
+      describe "when passing invalid value" do
+
+        it "is raise InvalidArgumentError" do
+          lambda{
+            subject.send :attributes=, :bad_value
+          }.must_raise ActiveRedis::InvalidArgumentError
+        end
+
+      end
+
+      describe "when passing valid value" do
+
+        describe "when value is Hash" do
+
+          it "is mapping passing values to attributes" do
+            subject.expects(:attr1=).with(:attr1_value)
+            lambda{
+              subject.send :attributes=, attr1: :attr1_value
+            }.must_be_silent
+          end
+
+        end
+
+        describe "when value is Array" do
+
+          it "is mapping passing values to attributes" do
+            subject.expects(:attr1=).with(:attr1_value)
+            lambda{
+              subject.send :attributes=, [:attr1, :attr1_value]
+            }.must_be_silent
+          end
+
+        end
+
+      end
+
+    end
+
+    describe "#attributes" do
+
+      before do
+        TestObject.stubs(:attributes_list).returns [:attr1]
+        subject.stubs(:attr1).returns :attr1_value
+      end
+
+      it "is return attributes hash" do
+        attrs = subject.attributes
+        attrs.must_be :count, 1
+        attrs.must_include :attr1
+      end
+
+    end
+
+  end
+
+  describe "class methods" do
+
+    describe "#attributes" do
+
+      describe "when passing valid value" do
+
+        it "is raise InvalidArgumentError" do
+          lambda{
+            TestObject.attributes :attr1
+          }.must_raise ActiveRedis::InvalidArgumentError
+        end
+
+      end
+
+      describe "when passing Hash value" do
+
+        before do
+          ActiveRedis::Constants::DEFAULT_ATTRIBUTES = {}
+        end
+
+        it "is call define_attributes_accessors" do
+          TestObject.expects(:define_attributes_accessors).with(attr1: :some)
+          lambda{
+            TestObject.attributes attr1: :some
+          }.must_be_silent
+          TestObject.must_respond_to :defined_attributes
+        end
+
+      end
+
+    end
+
+    describe "#define_attributes_accessors" do
+
+      describe "when attribute is already registered" do
+
+        it "is doesn't define accessors functions" do
+          TestObject.expects(:read_attribute).at_least 0
+          TestObject.expects(:write_attribute).at_least 0
+          TestObject.expects(:register_attribute).with(:attr1, :some).returns false
+          TestObject.define_attributes_accessors attr1: :some
+        end
+
+      end
+
+      describe "when trying define new attribute" do
+
+        it "is define read/write attribute's functions" do
+          TestObject.expects(:read_attribute).with(:attr1)
+          TestObject.expects(:write_attribute).with(:attr1)
+          TestObject.expects(:register_attribute).with(:attr1, :some).returns true
+          TestObject.define_attributes_accessors attr1: :some
+        end
+
+      end
+
+    end
+
+    describe "#attributes_list" do
+
+      before do
+        TestObject.defined_attributes = {attr1: :some}
+      end
+
+      it "is return array with attributes names" do
+        TestObject.attributes_list.must_equal ["attr1"]
+      end
+
+    end
+
+    describe "private methods" do
+
+      describe "#register_attribute" do
+
+        describe "when attribute already exists" do
+
+          before do
+            TestObject.defined_attributes = {attr1: :some}
+          end
+
+          it "is return false" do
+            result = TestObject.send :register_attribute, :attr1, :some
+            result.must_equal false
+          end
+
+        end
+
+        describe "when try to register new attribute" do
+
+          before do
+            TestObject.defined_attributes = {}
+          end
+
+          it "is return true" do
+            result = TestObject.send :register_attribute, :attr1, :some
+            TestObject.defined_attributes.must_include :attr1
+            result.must_equal true
+          end
+
+        end
+
+      end
+
+      describe "#attribute_class" do
+
+        before do
+          TestObject.defined_attributes = {attr1: {class: :attr1_class}}
+        end
+
+        it "is return associated class" do
+          result = TestObject.send :attribute_class, :attr1
+          result.must_equal :attr1_class
+        end
+
+      end
+
+      describe "#read_attribute" do
+
+        it "is define read method for attribute" do
+          TestObject.expects(:define_method).with(:attr1)
+          TestObject.send :read_attribute, :attr1
+        end
+
+      end
+
+
+      describe "#write_attribute" do
+
+        it "is define write method for attribute" do
+          TestObject.expects(:define_method).with("attr1=")
+          TestObject.send :write_attribute, :attr1
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/specs/calculations_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(File.realdirpath(__FILE__)) + '/test_helper.rb'
+require 'active_redis/calculations'
+require 'active_redis/constants'
+require 'active_redis/errors'
+
+describe ActiveRedis::Calculations do
+
+  let(:connection) { mock() }
+
+  before do
+    TestObject.send :extend, ActiveRedis::Calculations
+    ActiveRedis.stubs(:connection).returns connection
+  end
+
+  ActiveRedis::Constants::CALCULATION_METHODS.each do |method|
+
+    describe "##{method}" do
+
+      it "is call #{method} calculate on connection" do
+        connection.expects("calculate_#{method}")
+        TestObject.send method
+      end
+
+    end
+
+  end
+
+end

data/specs/config_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(File.realdirpath(__FILE__)) + '/test_helper.rb'
+require 'active_redis/config'
+
+describe ActiveRedis::Config do
+
+  subject { ActiveRedis::Config.new }
+
+  let(:options) { :connection_options }
+  let(:adapter) { :adapter }
+  let(:log) { :log }
+
+  it "is has connection_options attribute" do
+    subject.connection_options = options
+    subject.connection_options.must_be_same_as options
+  end
+
+  it "is has adapter attribute" do
+    subject.adapter = adapter
+    subject.adapter.must_be_same_as adapter
+  end
+
+  it "is has log attribute" do
+    subject.log = log
+    subject.log.must_be_same_as log
+  end
+
+end

data/specs/inspector_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(File.realdirpath(__FILE__)) + '/test_helper.rb'
+require 'active_redis/inspector'
+
+describe ActiveRedis::Inspector do
+
+  subject { TestObject.new }
+
+  before do
+    TestObject.send :include, ActiveRedis::Inspector
+  end
+
+  describe "#inspect" do
+
+    before do
+      TestObject.stubs(:attributes_list).returns []
+    end
+
+    it "is shouldn't be empty" do
+      subject.inspect.wont_be_empty
+    end
+
+    it "is contains class name" do
+      subject.inspect.must_match /TestObject/
+    end
+
+    describe "when attributes list isn't blank" do
+
+      before do
+        TestObject.stubs(:attributes_list).returns [:attr1]
+        subject.stubs(:attr1).returns "attr1_value"
+      end
+
+      it "is contains attribute name" do
+        subject.inspect.must_match /attr1/
+      end
+
+      it "is contains attribute value" do
+        subject.inspect.must_match /attr1_value/
+      end
+
+    end
+
+  end
+
+end