zermelo 1.1.0 → 1.2.0

data/spec/lib/zermelo/associations/range_index_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'zermelo/records/redis'
+require 'zermelo/associations/range_index'
+
+describe Zermelo::Associations::RangeIndex do
+
+  context 'redis', :redis => true do
+
+    let(:redis) { Zermelo.redis }
+
+    let(:time)  { Time.now }
+
+    module ZermeloExamples
+      class RedisRangeIndex
+        include Zermelo::Records::Redis
+        define_attributes :created_at => :timestamp
+        validates :created_at, :presence => true
+        range_index_by :created_at
+      end
+    end
+
+    it 'adds an entry to a sorted set indexing an attribute' do
+      example = ZermeloExamples::RedisRangeIndex.new(:id => '1',
+        :created_at => time)
+      expect(example).to be_valid
+      expect(example.save).to be true
+
+      expect(redis.exists('redis_range_index::indices:by_created_at')).to be true
+      expect(redis.zrange('redis_range_index::indices:by_created_at', 0, -1, :withscores => true)).to eq([
+        ['1', time.to_f]
+      ])
+    end
+
+    it 'removes an entry from a sorted set indexing an attribute' do
+      time_2 = time + 100
+
+      example = ZermeloExamples::RedisRangeIndex.new(:id => '1',
+        :created_at => time)
+      example.save
+
+      example_2 = ZermeloExamples::RedisRangeIndex.new(:id => '2',
+        :created_at => time_2)
+      example_2.save
+
+      expect(redis.zrange('redis_range_index::indices:by_created_at', 0, -1, :withscores => true)).to eq([
+        ['1', time.to_f],
+        ['2', time_2.to_f]
+      ])
+
+      example.destroy
+
+      expect(redis.zrange('redis_range_index::indices:by_created_at', 0, -1, :withscores => true)).to eq([
+        ['2', time_2.to_f]
+      ])
+    end
+
+    it 'changes an entry in a sorted set indexing an attribute' do
+      example = ZermeloExamples::RedisRangeIndex.new(:id => '1',
+        :created_at => time)
+      example.save
+
+      expect(redis.zrange('redis_range_index::indices:by_created_at', 0, -1, :withscores => true)).to eq([
+        ['1', time.to_f]
+      ])
+
+      time_2 = time + 100
+      example.created_at = time_2
+      example.save
+
+      expect(redis.zrange('redis_range_index::indices:by_created_at', 0, -1, :withscores => true)).to eq([
+        ['1', time_2.to_f]
+      ])
+    end
+
+  end
+
+end

data/spec/lib/zermelo/associations/singular_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+require 'zermelo/records/redis'
+require 'zermelo/associations/singular'
+
+describe Zermelo::Associations::Singular do
+
+  context 'has_one' do
+
+    shared_examples "has_one functions work", :has_one => true do
+
+      it 'returns associated ids for multiple parent ids' do
+        create_parent(:id => '8')
+        create_parent(:id => '9')
+        create_parent(:id => '10')
+
+        time = Time.now.to_i
+
+        create_child(parent_class.find_by_id('9'),  :id => '3')
+        create_child(parent_class.find_by_id('10'), :id => '4')
+
+        assoc_ids = parent_class.intersect(:id => ['8', '9', '10']).
+          associated_ids_for(:child)
+        expect(assoc_ids).to eq('8'  => nil,
+                                '9'  => '3',
+                                '10' => '4')
+      end
+
+      it 'calls before/after_read callbacks when the value is read' # do
+      #   create_parent(:id => '8')
+      #   parent = parent_class.find_by_id('8')
+
+      #   expect(parent.read).to be_nil
+      #   expect(parent.child).to be_nil
+      #   expect(parent.read).to eq([:pre, :post])
+      # end
+
+    end
+
+    context 'redis', :redis => true, :has_one => true do
+
+      let(:redis) { Zermelo.redis }
+
+      module ZermeloExamples
+        class AssociationsHasOneParentRedis
+          include Zermelo::Records::Redis
+          has_one :child, :class_name => 'ZermeloExamples::AssociationsHasOneChildRedis',
+            :inverse_of => :parent
+        end
+
+        class AssociationsHasOneChildRedis
+          include Zermelo::Records::Redis
+          belongs_to :parent, :class_name => 'ZermeloExamples::AssociationsHasOneParentRedis',
+            :inverse_of => :child
+        end
+      end
+
+      let(:parent_class) { ZermeloExamples::AssociationsHasOneParentRedis }
+      let(:child_class) { ZermeloExamples::AssociationsHasOneChildRedis }
+
+      # parent and child keys
+      let(:pk) { 'associations_has_one_parent_redis' }
+      let(:ck) { 'associations_has_one_child_redis' }
+
+      def create_parent(attrs = {})
+        redis.sadd("#{pk}::attrs:ids", attrs[:id])
+      end
+
+      def create_child(parent, attrs = {})
+        redis.hset("#{ck}:#{attrs[:id]}:assocs:belongs_to", 'parent_id', parent.id)
+        redis.hset("#{pk}:#{parent.id}:assocs:has_one", 'child_id', attrs[:id])
+        redis.sadd("#{ck}::attrs:ids", attrs[:id])
+      end
+
+      it "sets and retrieves a record via a has_one association" do
+        create_parent(:id => '8')
+
+        child = child_class.new(:id => '22')
+        expect(child.save).to be true
+
+        parent = parent_class.find_by_id('8')
+        parent.child = child
+
+        expect(redis.keys('*')).to match_array([
+          "#{pk}::attrs:ids",
+          "#{pk}:8:assocs:has_one",
+          "#{ck}::attrs:ids",
+          "#{ck}:22:assocs:belongs_to"
+        ])
+
+        expect(redis.hgetall("#{pk}:8:assocs:has_one")).to eq("child_id" => "22")
+
+        expect(redis.smembers("#{ck}::attrs:ids")).to eq(["22"])
+
+        expect(redis.hgetall("#{ck}:22:assocs:belongs_to")).to eq(
+          'parent_id' => '8'
+        )
+
+        parent2 = parent_class.find_by_id('8')
+        child2 = parent2.child
+        expect(child2).not_to be_nil
+
+        expect(child2.id).to eq('22')
+        expect(child2.parent.id).to eq('8')
+      end
+
+      it 'clears the belongs_to association when the child record is deleted' do
+        create_parent(:id => '8')
+        parent = parent_class.find_by_id('8')
+        create_child(parent, :id => '3')
+        child = child_class.find_by_id('3')
+
+        expect(redis.keys).to match_array([
+          "#{pk}::attrs:ids",
+          "#{pk}:8:assocs:has_one",
+          "#{ck}::attrs:ids",
+          "#{ck}:3:assocs:belongs_to"
+        ])
+
+        child.destroy
+
+        expect(redis.keys).to match_array([
+          "#{pk}::attrs:ids",
+        ])
+      end
+
+      it "clears the belongs_to association when the parent record is deleted" do
+        create_parent(:id => '8')
+        parent = parent_class.find_by_id('8')
+        create_child(parent, :id => '3')
+
+        expect(redis.keys).to match_array([
+          "#{pk}::attrs:ids",
+          "#{pk}:8:assocs:has_one",
+          "#{ck}::attrs:ids",
+          "#{ck}:3:assocs:belongs_to"
+        ])
+
+        parent.destroy
+
+        expect(redis.keys).to match_array([
+          "#{ck}::attrs:ids"
+        ])
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/zermelo/associations/unique_index_spec.rb

@@ -1,6 +1,62 @@
 require 'spec_helper'
+require 'zermelo/records/redis'
 require 'zermelo/associations/unique_index'
 
-describe Zermelo::Associations::UniqueIndex, :redis => true do
+describe Zermelo::Associations::UniqueIndex do
 
-end
+  context 'redis', :redis => true do
+
+    let(:redis) { Zermelo.redis }
+
+    module ZermeloExamples
+      class RedisUniqueIndex
+        include Zermelo::Records::Redis
+        define_attributes :name => :string
+        validates :name, :presence => true
+        unique_index_by :name
+      end
+    end
+
+    it 'adds an entry to a hash indexing an attribute' do
+      example = ZermeloExamples::RedisUniqueIndex.new(:id => '1',
+        :name => 'John Smith')
+      expect(example).to be_valid
+      expect(example.save).to be true
+
+      expect(redis.exists('redis_unique_index::indices:by_name')).to be true
+      expect(redis.hgetall('redis_unique_index::indices:by_name')).to eq('string:John%20Smith' => '1')
+    end
+
+    it 'removes an entry from a hash indexing an attribute' do
+      example = ZermeloExamples::RedisUniqueIndex.new(:id => '1',
+        :name => 'John Smith')
+      example.save
+
+      example_2 = ZermeloExamples::RedisUniqueIndex.new(:id => '2',
+        :name => 'Roger Wilco')
+      example_2.save
+
+      expect(redis.hgetall('redis_unique_index::indices:by_name')).to eq('string:John%20Smith' => '1',
+        'string:Roger%20Wilco' => '2')
+
+      example.destroy
+
+      expect(redis.hgetall('redis_unique_index::indices:by_name')).to eq({'string:Roger%20Wilco' => '2'})
+    end
+
+    it 'changes an entry in a hash indexing an attribute' do
+      example = ZermeloExamples::RedisUniqueIndex.new(:id => '1',
+        :name => 'John Smith')
+      example.save
+
+      expect(redis.hgetall('redis_unique_index::indices:by_name')).to eq('string:John%20Smith' => '1')
+
+      example.name = 'Jane Jones'
+      example.save
+
+      expect(redis.hgetall('redis_unique_index::indices:by_name')).to eq('string:Jane%20Jones' => '1')
+    end
+
+  end
+
+end

data/spec/lib/zermelo/filter_spec.rb

@@ -0,0 +1,363 @@
+require 'spec_helper'
+require 'zermelo/filter'
+require 'zermelo/records/redis'
+require 'zermelo/records/influxdb'
+require 'zermelo/associations/range_index'
+
+describe Zermelo::Filter do
+
+  shared_examples 'filter functions work', :filter => true do
+
+    let(:time) { Time.now }
+
+    let(:active) {
+      create_example(:id => '8', :name => 'John Jones', :active => true,
+        :created_at => (time - 200).to_f)
+    }
+
+    let(:inactive) {
+      create_example(:id => '9', :name => 'James Brown', :active => false,
+        :created_at => (time - 100).to_f)
+    }
+
+    before do
+      active; inactive
+    end
+
+    it "returns all record ids" do
+      examples = example_class.ids
+      expect(examples).not_to be_nil
+      expect(examples).to be_an(Array)
+      expect(examples.size).to eq(2)
+      expect(examples).to contain_exactly('8', '9')
+    end
+
+    it "returns a count of records" do
+      example_count = example_class.count
+      expect(example_count).not_to be_nil
+      expect(example_count).to be_an(Integer)
+      expect(example_count).to eq(2)
+    end
+
+    it "returns all records" do
+      examples = example_class.all
+      expect(examples).not_to be_nil
+      expect(examples).to be_an(Array)
+      expect(examples.size).to eq(2)
+      expect(examples.map(&:id)).to contain_exactly('9', '8')
+    end
+
+    it "finds a record by id" do
+      example = example_class.find_by_id('8')
+      expect(example).not_to be_nil
+      expect(example.id).to eq('8')
+      expect(example.name).to eq('John Jones')
+    end
+
+    it "finds records by a uniquely indexed value" do
+      examples = example_class.intersect(:name => 'John Jones').all
+      expect(examples).not_to be_nil
+      expect(examples).to be_an(Array)
+      expect(examples.size).to eq(1)
+      example = examples.first
+      expect(example.id).to eq('8')
+      expect(example.name).to eq('John Jones')
+    end
+
+    it "filters all class records by indexed attribute values" do
+      example = example_class.intersect(:active => true).all
+      expect(example).not_to be_nil
+      expect(example).to be_an(Array)
+      expect(example.size).to eq(1)
+      expect(example.map(&:id)).to eq(['8'])
+    end
+
+    it 'filters by id attribute values' do
+      example = example_class.intersect(:id => '9').all
+      expect(example).not_to be_nil
+      expect(example).to be_an(Array)
+      expect(example.size).to eq(1)
+      expect(example.map(&:id)).to eq(['9'])
+    end
+
+    it 'filters by multiple id attribute values' do
+      create_example(:id => '10', :name => 'Jay Johns', :active => true,
+        :created_at => (time - 50).to_f)
+
+      examples = example_class.intersect(:id => ['8', '10']).all
+      expect(examples).not_to be_nil
+      expect(examples).to be_an(Array)
+      expect(examples.size).to eq(2)
+      expect(examples.map(&:id)).to match_array(['8', '10'])
+    end
+
+    it 'supports sequential intersection and union operations' do
+      examples = example_class.intersect(:active => true).
+                   union(:active => false).all
+      expect(examples).not_to be_nil
+      expect(examples).to be_an(Array)
+      expect(examples.size).to eq(2)
+      expect(examples.map(&:id)).to match_array(['8', '9'])
+    end
+
+    it "chains two intersect filters together" do
+      example = example_class.intersect(:active => true).
+        intersect(:name => 'John Jones').all
+      expect(example).not_to be_nil
+      expect(example).to be_an(Array)
+      expect(example.size).to eq(1)
+      expect(example.map(&:id)).to eq(['8'])
+    end
+
+    it "allows multiple attributes in an intersect filter" do
+      example = example_class.intersect(:active => true,
+        :name => 'John Jones').all
+      expect(example).not_to be_nil
+      expect(example).to be_an(Array)
+      expect(example.size).to eq(1)
+      expect(example.map(&:id)).to eq(['8'])
+    end
+
+    it "chains an intersect and a diff filter together" do
+      create_example(:id => '3', :name => 'Fred Bloggs',
+        :active => 'true')
+
+      example = example_class.intersect(:active => true).diff(:name => 'Fred Bloggs').all
+      expect(example).not_to be_nil
+      expect(example).to be_an(Array)
+      expect(example.size).to eq(1)
+      expect(example.map(&:id)).to eq(['8'])
+    end
+
+    it "does not return a spurious record count when records don't exist" do
+      scope = example_class.intersect(:id => ['3000', '5000'])
+      expect(scope.all).to be_empty
+      expect(scope.count).to eq 0
+    end
+
+    it 'finds records by regex match against a uniquely indexed value' do
+      examples = example_class.intersect(:name => /hn Jones/).all
+      expect(examples).not_to be_nil
+      expect(examples).to be_an(Array)
+      expect(examples.size).to eq(1)
+      example = examples.first
+      expect(example.id).to eq('8')
+      expect(example.name).to eq('John Jones')
+    end
+
+    it 'cannot find records by regex match against non-string values' do
+      expect {
+        example_class.intersect(:active => /alse/).all
+      }.to raise_error("Can't query non-string values via regexp")
+    end
+
+    it 'can append to a filter chain fragment more than once' do
+      inter = example_class.intersect(:active => true)
+      expect(inter.ids).to eq(['8'])
+
+      union = inter.union(:name => 'James Brown')
+      expect(union.ids).to match_array(['8', '9'])
+
+      diff = inter.diff(:id => ['8'])
+      expect(diff.ids).to eq([])
+    end
+
+    it "ANDs multiple union arguments, not ORs them" do
+      create_example(:id => '10', :name => 'Jay Johns', :active => true)
+      examples = example_class.intersect(:id => ['8']).
+                   union(:id => ['9', '10'], :active => true).all
+      expect(examples).not_to be_nil
+      expect(examples).to be_an(Array)
+      expect(examples.size).to eq(2)
+      expect(examples.map(&:id)).to match_array(['8', '10'])
+    end
+
+    it "ANDs multiple diff arguments, not ORs them" do
+      create_example(:id => '10', :name => 'Jay Johns', :active => true)
+      examples = example_class.intersect(:id => ['8', '9', '10']).
+                   diff(:id => ['9', '10'], :active => false).all
+      expect(examples).not_to be_nil
+      expect(examples).to be_an(Array)
+      expect(examples.size).to eq(2)
+      expect(examples.map(&:id)).to match_array(['8', '10'])
+    end
+
+    it 'supports a regex as argument in union after intersect' do
+      create_example(:id => '10', :name => 'Jay Johns', :active => true)
+      examples = example_class.intersect(:id => ['8']).
+                   union(:id => ['9', '10'], :name => [nil, /^Jam/]).all
+      expect(examples).not_to be_nil
+      expect(examples).to be_an(Array)
+      expect(examples.size).to eq(2)
+      expect(examples.map(&:id)).to match_array(['8', '9'])
+    end
+
+    it 'allows intersection operations across multiple values for an attribute' do
+      create_example(:id => '10', :name => 'Jay Johns', :active => true)
+
+      examples = example_class.intersect(:name => ['Jay Johns', 'James Brown']).all
+      expect(examples).not_to be_nil
+      expect(examples).to be_an(Array)
+      expect(examples.size).to eq(2)
+      expect(examples.map(&:id)).to match_array(['9', '10'])
+    end
+
+    it 'allows union operations across multiple values for an attribute' do
+      create_example(:id => '10', :name => 'Jay Johns', :active => true)
+
+      examples = example_class.intersect(:active => false).
+                   union(:name => ['Jay Johns', 'James Brown']).all
+      expect(examples).not_to be_nil
+      expect(examples).to be_an(Array)
+      expect(examples.size).to eq(2)
+      expect(examples.map(&:id)).to match_array(['9', '10'])
+    end
+
+    it 'excludes particular records' do
+      example = example_class.diff(:active => true).all
+      expect(example).not_to be_nil
+      expect(example).to be_an(Array)
+      expect(example.size).to eq(1)
+      expect(example.map(&:id)).to eq(['9'])
+    end
+
+  end
+
+  context 'redis', :redis => true, :filter => true do
+
+    let(:redis) { Zermelo.redis }
+
+    module ZermeloExamples
+      class FilterRedis
+        include Zermelo::Records::Redis
+        define_attributes :name       => :string,
+                          :active     => :boolean,
+                          :created_at => :timestamp
+        validates :name, :presence => true
+        validates :active, :inclusion => {:in => [true, false]}
+        index_by :active
+        range_index_by :created_at
+        unique_index_by :name
+      end
+    end
+
+    let(:example_class) { ZermeloExamples::FilterRedis }
+
+    # parent and child keys
+    let(:ek) { 'filter_redis' }
+
+    def create_example(attrs = {})
+      redis.hmset("#{ek}:#{attrs[:id]}:attrs",
+        {'name' => attrs[:name], 'active' => attrs[:active]}.to_a.flatten)
+      redis.sadd("#{ek}::indices:by_active:boolean:#{!!attrs[:active]}", attrs[:id])
+      name = attrs[:name].gsub(/%/, '%%').gsub(/ /, '%20').gsub(/:/, '%3A')
+      redis.hset("#{ek}::indices:by_name", "string:#{name}", attrs[:id])
+      redis.zadd("#{ek}::indices:by_created_at", attrs[:created_at].to_f, attrs[:id])
+      redis.sadd("#{ek}::attrs:ids", attrs[:id])
+    end
+
+    # following only working in Redis for now
+    it 'sorts records by an attribute' do
+      example = example_class.sort(:name, :order => 'alpha').all
+      expect(example).not_to be_nil
+      expect(example).to be_an(Array)
+      expect(example.size).to eq(2)
+      expect(example.map(&:id)).to eq(['9', '8'])
+    end
+
+    it 'sorts by multiple fields' do
+      data = {:active => true, :created_at => Time.now}
+      create_example(data.merge(:id => '1', :name => 'abc'))
+      create_example(data.merge(:id => '2', :name => 'def'))
+      create_example(data.merge(:id => '3', :name => 'abc'))
+      create_example(data.merge(:id => '4', :name => 'def'))
+
+      expect(example_class.sort(:name => :asc, :id => :desc).map(&:id)).to eq(
+        ['9', '8', '3', '1', '4', '2']
+      )
+    end
+
+    # NB sort is case-sensitive, may want a non-case sensitive version
+    it "returns paginated query responses" do
+      data = {:active => true, :created_at => Time.now}
+      create_example(data.merge(:id => '1', :name => 'mno'))
+      create_example(data.merge(:id => '2', :name => 'abc'))
+      create_example(data.merge(:id => '3', :name => 'jkl'))
+      create_example(data.merge(:id => '4', :name => 'ghi'))
+      create_example(data.merge(:id => '5', :name => 'def'))
+
+      expect(example_class.sort(:id).page(1, :per_page => 3).map(&:id)).to eq(['1', '2', '3'])
+      expect(example_class.sort(:id).page(2, :per_page => 2).map(&:id)).to eq(['3', '4'])
+      expect(example_class.sort(:id).page(3, :per_page => 2).map(&:id)).to eq(['5', '8'])
+      expect(example_class.sort(:id).page(3, :per_page => 3).map(&:id)).to eq(['9'])
+
+      expect(example_class.sort(:name).page(1, :per_page => 3).map(&:id)).to eq(['9', '8', '2'])
+      expect(example_class.sort(:name).page(2, :per_page => 3).map(&:id)).to eq(['5', '4', '3'])
+      expect(example_class.sort(:name).page(3, :per_page => 3).map(&:id)).to eq(['1'])
+      expect(example_class.sort(:name).page(4, :per_page => 3).map(&:id)).to eq([])
+    end
+
+    it 'filters by records created before a certain time' do
+      examples = example_class.intersect(:created_at => Zermelo::Filters::IndexRange.new(nil, time - 150, :by_score => true))
+      expect(examples.count).to eq(1)
+      expect(examples.map(&:id)).to eq(['8'])
+    end
+
+    it 'filters by records created after a certain time' do
+      examples = example_class.intersect(:created_at => Zermelo::Filters::IndexRange.new(time - 150, nil, :by_score => true))
+      expect(examples.count).to eq(1)
+      expect(examples.map(&:id)).to eq(['9'])
+    end
+
+    it 'raises an error when trying to filter on a non-indexed value' do
+      expect {
+        example_class.intersect(:email => 'jjones@example.com').all
+      }.to raise_error("'email' property is not indexed")
+    end
+
+  end
+
+  context 'influxdb', :influxdb => true, :filter => true do
+
+    let(:influxdb) { Zermelo.influxdb }
+
+    module ZermeloExamples
+      class FilterInfluxDB
+        include Zermelo::Records::InfluxDB
+        define_attributes :name       => :string,
+                          :active     => :boolean,
+                          :created_at => :timestamp
+        validates :name, :presence => true
+        validates :active, :inclusion => {:in => [true, false]}
+        index_by :active
+        range_index_by :created_at
+        unique_index_by :name
+      end
+    end
+
+    let(:example_class) { ZermeloExamples::FilterInfluxDB }
+
+    # parent and child keys
+    let(:ek) { 'filter_influx_db' }
+
+    def create_example(attrs = {})
+      attrs[:active] = attrs[:active].to_s unless attrs[:active].nil?
+      attrs[:time]   = attrs[:created_at].to_i
+      Zermelo.influxdb.write_point("#{ek}/#{attrs[:id]}", attrs)
+    end
+
+    # need to fix the influxdb driver to work with these (see Redis examples above)
+    it 'sorts records by an attribute'
+    it 'sorts by multiple fields'
+    it "returns paginated query responses"
+    it 'filters by records created before a certain time'
+    it 'filters by records created after a certain time'
+
+    it 'raises an error when trying to filter on a non-indexed value' do
+      expect {
+        example_class.intersect(:email => 'jjones@example.com').all
+      }.to raise_error("Field email doesn't exist in series filter_influx_db/10")
+    end
+
+  end
+end

data/spec/lib/zermelo/locks/redis_lock_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 require 'zermelo/locks/redis_lock'
-require 'zermelo/records/redis_record'
+require 'zermelo/records/redis'
 
 describe Zermelo::Locks::RedisLock, :redis => true do
 
@@ -8,12 +8,12 @@ describe Zermelo::Locks::RedisLock, :redis => true do
 
   module Zermelo
     class RedisLockExample
-      include Zermelo::Records::RedisRecord
+      include Zermelo::Records::Redis
       define_attributes :name => :string
     end
 
     class AnotherExample
-      include Zermelo::Records::RedisRecord
+      include Zermelo::Records::Redis
       define_attributes :age => :integer
     end
   end