redstruct 0.1.7 → 0.2.0

data/test/redstruct/set_test.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Redstruct
+  class SetTest < Redstruct::Test
+    def setup
+      super
+      @factory = create_factory
+      @set = @factory.set('set')
+    end
+
+    def test_clear
+      @set << 'item'
+      refute @set.empty?, 'ensure it is not empty before clearing'
+
+      @set.clear
+      assert @set.empty?, 'should be empty after clearing'
+    end
+
+    # assumes srandmember works correctly about the randomization part
+    def test_random
+      ensure_command_called(@set, :srandmember, 1).twice
+      assert_nil @set.random, 'should return nothing when the set is empty'
+
+      @set << 'a'
+      assert_equal 'a', @set.random, 'should return a, as it is the only member anyway'
+
+      amount = rand(10) + 2
+      requested = amount / 2
+      @set.add(*(1..amount).map { |i| i })
+
+      ensure_command_called(@set, :srandmember, requested).once
+      assert_equal requested, @set.random(count: requested).size, 'should return the amount of items requested'
+    end
+
+    def test_empty?
+      assert @set.empty?, 'should be initially empty'
+      @set << 'a'
+      refute @set.empty?, 'should not be empty once it has one element'
+      @set.clear
+      assert @set.empty?, 'should be empty after clearing'
+    end
+
+    def test_contain?
+      refute @set.contain?('a'), 'should not contain anything'
+      @set << 'a'
+      assert @set.contain?('a'), 'should now contain a'
+    end
+
+    def test_add
+      assert @set.empty?, 'set should be empty before any addition'
+      assert_equal 2, @set.add(1, 2), 'should return the number of added elements'
+      assert_equal 1, @set.add(1, 2, 3), 'should return only the number of added elements'
+      assert_equal ::Set.new(%w[1 2 3]), @set.to_set, 'should return a set containing 1, 2, 3'
+    end
+
+    def test_pop
+      values = %w[1 2 3]
+      assert @set.empty?, 'should start empty'
+
+      @set.add(*values)
+      popped = @set.pop
+      assert values.include?(popped), 'should have popped one of the added values'
+
+      expected = values - [popped]
+      assert_equal ::Set.new(expected), @set.to_set, 'should return a set containing the remaining elements'
+    end
+
+    def test_remove
+      values = %w[1 2 3]
+      assert @set.empty?, 'should start empty'
+
+      @set.add(*values)
+      assert @set.remove('1'), 'should remove the element correctly'
+      assert_equal ::Set.new(%w[2 3]), @set.to_set, 'should return the remaining elements'
+
+      assert_equal 2, @set.remove(2, 3, 4), 'should remove 2 elements only'
+      assert @set.empty?, 'should be empty once we remove everything'
+    end
+
+    def test_size
+      values = %w[1 2 3]
+      assert_equal 0, @set.size, 'should have no elements initially'
+
+      @set.add(*values)
+      assert_equal values.size, @set.size, 'should return the correct number of elements'
+    end
+
+    def test_difference
+      set_contents = %w[1 2 3 4]
+      set2_contents = %w[3 4 5 6]
+
+      set2 = @factory.set('set2')
+
+      @set.add(*set_contents)
+      set2.add(*set2_contents)
+
+      assert_equal ::Set.new(%w[1 2]), @set - set2, 'should return elements not contained in set2'
+      assert_equal ::Set.new(%w[5 6]), set2 - @set, 'should return elements not contained in set'
+
+      assert_equal ::Set.new(set_contents), @set.to_set, 'should still be the same'
+      assert_equal ::Set.new(set2_contents), set2.to_set, 'should still be the same'
+    end
+
+    def test_difference_dest
+      set_contents = %w[1 2 3 4]
+      set2_contents = %w[3 4 5 6]
+
+      set2 = @factory.set('set2')
+      set3 = @factory.set('set3')
+
+      @set.add(*set_contents)
+      set2.add(*set2_contents)
+
+      assert_equal 2, @set.difference(set2, dest: set3), 'should have 2 elements stored in the new set'
+      assert_equal ::Set.new(%w[1 2]), set3.to_set, 'should return elements not contained in set2'
+
+      assert_equal ::Set.new(set_contents), @set.to_set, 'should still be the same'
+      assert_equal ::Set.new(set2_contents), set2.to_set, 'should still be the same'
+    end
+
+    def test_intersection
+      set_contents = %w[1 2 3 4]
+      set2_contents = %w[3 4 5 6]
+
+      set2 = @factory.set('set2')
+
+      @set.add(*set_contents)
+      set2.add(*set2_contents)
+
+      assert_equal ::Set.new(%w[3 4]), @set | set2, 'should return elements contained in both sets'
+      assert_equal ::Set.new(%w[3 4]), set2 | @set, 'should return elements contained in both sets'
+
+      assert_equal ::Set.new(set_contents), @set.to_set, 'should still be the same'
+      assert_equal ::Set.new(set2_contents), set2.to_set, 'should still be the same'
+    end
+
+    def test_intersection_dest
+      set_contents = %w[1 2 3 4]
+      set2_contents = %w[3 4 5 6]
+
+      set2 = @factory.set('set2')
+      set3 = @factory.set('set3')
+
+      @set.add(*set_contents)
+      set2.add(*set2_contents)
+
+      assert_equal 2, @set.intersection(set2, dest: set3), 'should have 2 elements stored in the new set'
+      assert_equal ::Set.new(%w[3 4]), set3.to_set, 'should return elements contained in both sets'
+
+      assert_equal ::Set.new(set_contents), @set.to_set, 'should still be the same'
+      assert_equal ::Set.new(set2_contents), set2.to_set, 'should still be the same'
+    end
+
+    def test_union
+      set_contents = %w[1 2 3 4]
+      set2_contents = %w[3 4 5 6]
+
+      set2 = @factory.set('set2')
+
+      @set.add(*set_contents)
+      set2.add(*set2_contents)
+
+      assert_equal ::Set.new(%w[1 2 3 4 5 6]), @set + set2, 'should return elements contained in either sets'
+      assert_equal ::Set.new(%w[1 2 3 4 5 6]), set2 + @set, 'should return elements contained in either sets'
+
+      assert_equal ::Set.new(set_contents), @set.to_set, 'should still be the same'
+      assert_equal ::Set.new(set2_contents), set2.to_set, 'should still be the same'
+    end
+
+    def test_union_dest
+      set_contents = %w[1 2 3 4]
+      set2_contents = %w[3 4 5 6]
+
+      set2 = @factory.set('set2')
+      set3 = @factory.set('set3')
+
+      @set.add(*set_contents)
+      set2.add(*set2_contents)
+
+      assert_equal 6, @set.union(set2, dest: set3), 'should have 6 elements stored in the new set'
+      assert_equal ::Set.new(%w[1 2 3 4 5 6]), set3.to_set, 'should return elements contained in either sets'
+
+      assert_equal ::Set.new(set_contents), @set.to_set, 'should still be the same'
+      assert_equal ::Set.new(set2_contents), set2.to_set, 'should still be the same'
+    end
+
+    def test_to_a
+      values = %w[1 2 3]
+      @set.add(*values)
+
+      assert_equal @set.to_a.sort, values, 'should return an array containing the correct values'
+    end
+
+    def test_to_set
+      values = %w[1 2 3]
+      @set.add(*values)
+
+      assert_equal ::Set.new(values), @set.to_set, 'should return the correct set'
+    end
+
+    def test_each
+      values = %w[a b c d aa]
+      @set.add(*values)
+
+      missing = values.dup
+      @set.each do |word|
+        assert values.include?(word), 'should be in the values'
+        missing.delete(word)
+      end
+      assert_empty missing, 'should not have missed anything'
+
+      matched = ::Set.new
+      @set.each(match: 'a*') { |word| matched << word }
+      assert_equal ::Set.new(%w[a aa]), matched, 'should contain a and aa only'
+    end
+  end
+end

data/test/redstruct/sorted_set/slice_test.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Redstruct
+  class SortedSet
+    class SliceTest < Redstruct::Test
+    end
+  end
+end

data/test/redstruct/sorted_set_test.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Redstruct
+  class SortedTest < Redstruct::Test
+    def setup
+      super
+      @factory = create_factory
+      @set = @factory.sorted_set('zset')
+    end
+
+    def test_initialize
+      refute @set.lexicographic?, 'should not be a lexicographically sorted set'
+
+      lex = @factory.sorted_set('lzset', lex: true)
+      assert lex.lexicographic?, 'should be marked as a lexicographically sorted set'
+    end
+
+    def test_clear
+      assert @set.empty?, 'should initially be empty'
+      @set.add(1, 'a')
+      refute @set.empty?, 'should not be empty'
+
+      assert @set.clear, 'should have been cleared'
+      assert @set.empty?, 'should now be empty again'
+    end
+
+    def test_empty?
+      assert @set.empty?, 'should be empty initially'
+      @set.add(1, 'a')
+      refute @set.empty?, 'should now not be empty'
+    end
+
+    def test_add
+      values = { 1 => 'a', 2 => 'c', 3 => 'b' }
+      assert_equal 3, @set.add(*values.keys.zip(values.values)), 'should have added 3 items'
+      assert_equal 0, @set.add(1, 'a'), 'should not add pre-existing value'
+      assert_equal ::Set.new(%w[a b c]), @set.to_set, 'should contain exactly the values added'
+    end
+
+    def test_add_exists
+      assert_equal 0, @set.add([1, 'a'], exists: true), 'should not have added anything items'
+      assert @set.empty?, 'should not contain anything'
+
+      @set.add([2, 'a'])
+      assert_equal 2.0, @set.score('a'), 'should have score of 2'
+      assert_equal 1, @set.add([1, 'a'], exists: true), 'should have added 1 element'
+      assert_equal 1.0, @set.score('a'), 'should have score of 1'
+    end
+
+    def test_add_overwrite
+      @set.add([2, 'b'])
+      assert_equal 0, @set.add([3, 'b'], overwrite: false), 'should not overwrite pre-existing value'
+      assert_equal 2.0, @set.score('b'), 'should still have old score'
+      assert_equal 1, @set.add([3, 'b'], overwrite: true), 'should have overwritten pre-existing value'
+      assert_equal 3.0, @set.score('b'), 'should now have score of 3'
+    end
+
+    def test_add_lex
+      set = @factory.sorted_set('zset', lex: true)
+      assert_equal 2, set.add([1, 'c'], [2, 'd']), 'should have added 2 elements'
+      assert_equal 2, set.add('a', 'b'), 'should have added 2 elements'
+
+      assert_equal %w[a b c d], set.to_a, 'should be lexicographically sorted'
+      %w[a b c d].each do |letter|
+        assert_equal 0.0, set.score(letter), 'should have a score of 0'
+      end
+    end
+
+    def test_increment
+      assert_equal 1.0, @set.increment('a'), 'should have a default score of 1.0'
+      assert_equal 3.0, @set.increment('a', by: 2.0), 'should have incremented the score by 2'
+      assert_equal 3.0, @set.score('a'), 'should have the correct score of 3.0'
+    end
+
+    def test_increment_lex
+      set = @factory.sorted_set('zset', lex: true)
+      assert_raises(NotImplementedError, 'should not be able to increment scores for lexicographic sets') do
+        set.increment('a')
+      end
+    end
+
+    def test_decrement
+      assert_equal(-1.0, @set.decrement('a'), 'should have a default score of -1.0')
+      assert_equal(-3.0, @set.decrement('a', by: 2.0), 'should have decremented the score by 2')
+      assert_equal(-3.0, @set.score('a'), 'should have the correct score of -3.0')
+    end
+
+    def test_decrement_lex
+      set = @factory.sorted_set('zset', lex: true)
+      assert_raises(NotImplementedError, 'should not be able to decrement scores for lexicographic sets') do
+        set.decrement('a')
+      end
+    end
+
+    def test_size
+      assert_equal 0, @set.size, 'should have a size of 0 initially'
+      @set.add([1, 'a'], [2, 'b'], [3, 'c'])
+      assert_equal 3, @set.size, 'should have a size of 3'
+    end
+
+    # The slice structure has its own tests, so we only test the creation of
+    # a slice here.
+    def test_slice
+      slice = @set.slice
+      assert_equal @set.key, slice.key, 'should have the same object key'
+      assert_equal @set.factory, slice.factory, 'should have the same initial factory'
+      assert_equal '-inf', slice.lower, 'should have infinity as lower bound'
+      assert_equal '+inf', slice.upper, 'should have infinity as upper bound'
+      refute slice.exclusive, 'should not be exclusive by default'
+
+      slice = @set.slice(lower: 1, upper: 3, exclusive: true)
+      assert_equal '(1.0', slice.lower, 'should have exclusive 1.0 as lower bound'
+      assert_equal '(3.0', slice.upper, 'should have exclusive 3.0 as upper bound'
+
+      slice = @set.slice(lower: 1, upper: 3, exclusive: false)
+      assert_equal 1.0, slice.lower, 'should have inclusive 1.0 as lower bound'
+      assert_equal 3.0, slice.upper, 'should have inclusive 3.0 as upper bound'
+    end
+
+    def test_slice_lex
+      set = @factory.sorted_set('zset', lex: true)
+      slice = set.slice
+      assert slice.lex, 'should be a lexicographical slice'
+      assert_equal '-', slice.lower, 'should have lex infinity as lower bound'
+      assert_equal '+', slice.upper, 'should have lex infinity as upper bound'
+
+      slice = set.slice(lower: 'a', upper: 'd', exclusive: true)
+      assert_equal '(a', slice.lower, 'should have exclusive lower bound a'
+      assert_equal '(d', slice.upper, 'should have exclusive upper bound d'
+
+      slice = set.slice(lower: 'a', upper: 'd', exclusive: false)
+      assert_equal '[a', slice.lower, 'should have inclusive lower bound a'
+      assert_equal '[d', slice.upper, 'should have inclusive upper bound d'
+    end
+
+    def test_contain?
+      refute @set.contain?('a'), 'should not contain a initially'
+      @set.add([1, 'a'])
+      assert @set.contain?('a'), 'should now contain a'
+    end
+
+    def test_index
+      assert_nil @set.index('a'), 'should not return any index initially'
+      @set.add([2, 'b'], [1, 'a'])
+      assert_equal 0, @set.index('a'), 'should return correct index for a'
+      assert_equal 1, @set.index('b'), 'should return correct index for b'
+    end
+
+    def test_rindex
+      assert_nil @set.rindex('a'), 'should not return any index initially'
+      @set.add([2, 'b'], [1, 'a'])
+      assert_equal 1, @set.rindex('a'), 'should return correct index for a'
+      assert_equal 0, @set.rindex('b'), 'should return correct index for b'
+    end
+
+    def test_score
+      assert_nil @set.score('a'), 'should return nil when item not in the set'
+      @set.add([1, 'a'])
+      assert_equal 1.0, @set.score('a'), 'should return the correct score'
+    end
+
+    def test_remove
+      items = %w[a b c]
+      assert_equal 0, @set.remove(*items), 'should not have removed anything'
+
+      @set.add(*[1, 2, 3].zip(items))
+      @set.add([4, 'd'])
+      assert_equal 1, @set.remove('d', 'e'), 'should only remove 1 element'
+      assert_equal items, @set.to_a, 'should contain the correct elements'
+      assert_equal 3, @set.remove(*items), 'should have removed all 3 elements'
+      assert @set.empty?, 'should be empty now'
+    end
+
+    def test_to_a
+      assert_empty @set.to_a, 'should initially return an empty array'
+      @set.add([4, 'a'], [3, 'b'], [2, 'c'], [1, 'd'])
+      assert_equal %w[d c b a], @set.to_a, 'should return a sorted array'
+    end
+
+    def test_to_set
+      items = %w[a b]
+      assert_equal ::Set.new, @set.to_set, 'should return an empty set'
+      @set.add(*[1, 2].zip(items))
+      assert_equal ::Set.new(items), @set.to_set, 'should return a set containing the elements'
+    end
+
+    def test_each
+      values = %w[aa b c d a]
+      scores = %w[1 2 3 4 5]
+      sorted = scores.zip(values).sort_by { |pair| pair[0].to_i }
+      @set.add(*sorted)
+
+      received = []
+      @set.each do |word|
+        assert values.include?(word), 'should be in the values'
+        received << word
+      end
+      assert_equal received, @set.to_a, 'should have received it all in order'
+
+      received = []
+      @set.each(match: 'a*') { |word| received << word }
+      assert_equal %w[aa a], received, 'should contain a and aa only'
+    end
+
+    def test_each_with_scores
+      values = %w[aa b c d a]
+      scores = %w[1 2 3 4 5].map(&:to_f)
+      sorted = scores.zip(values).sort_by { |pair| pair[0].to_i }
+      @set.add(*sorted)
+
+      @set.each(with_scores: true).each_with_index do |(value, score), index|
+        assert_equal values[index], value, 'should receive the correct value'
+        assert_equal scores[index], score, 'should receive the correct score'
+      end
+    end
+  end
+end

data/test/redstruct/string_test.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Redstruct
+  class StringTest < Redstruct::Test
+  end
+end

data/test/redstruct/struct_test.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'test_helper'
+
+module Redstruct
+  class StructTest < Redstruct::Test
+    def setup
+      super
+      @factory = create_factory
+      @struct = @factory.struct('struct')
+    end
+
+    def test_initialize
+      key = @factory.prefix(SecureRandom.hex(4))
+      struct = Redstruct::Struct.new(key: key, factory: @factory)
+      assert_equal key, struct.key, 'should have key unchanged after initialization'
+    end
+
+    def test_exists?
+      refute @struct.exists?, 'struct should not yet exist'
+      write_struct
+      assert @struct.exists?, 'struct should exist if underlying redis key exists'
+    end
+
+    def test_delete
+      refute @struct.delete, 'should return false since the struct did not exist'
+      write_struct
+      assert @struct.delete, 'should return true since a key was actually deleted'
+    end
+
+    def test_expire
+      refute @struct.expire(1), 'should return false since no existing key was expired'
+      write_struct
+      assert @struct.expire(1), 'should have correctly expired the existing key'
+    end
+
+    def test_expire_at
+      refute @struct.expire_at(1), 'should return false since no existing key was expired'
+      write_struct
+      assert @struct.expire_at(1), 'should have correctly marked to key to be expired'
+      refute @struct.exists?, 'should not exist since it was marked to be expired 1 second after 1970-01-01'
+    end
+
+    def test_persist; end
+
+    def test_type; end
+
+    def test_ttl; end
+
+    def test_dump; end
+
+    def test_restore; end
+
+    # a struct has no set value, so use the redis connection to "cheat" and set one so the struct actually exists
+    def write_struct
+      @struct.connection.set(@struct.key, 'foo')
+    end
+    private :write_struct
+  end
+end

data/test/redstruct/utils/coercion_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Redstruct
+  module Utils
+    class CoercionTest < Redstruct::Test
+      def test_coerce_bool
+        refute Redstruct::Utils::Coercion.coerce_bool(nil), 'nil should be coerced to false'
+        refute Redstruct::Utils::Coercion.coerce_bool(false), 'false should be coerced to false'
+        refute Redstruct::Utils::Coercion.coerce_bool(0), '0 should be coerced to false'
+        refute Redstruct::Utils::Coercion.coerce_bool(0.0), '0.0 should be coerced to false'
+        assert Redstruct::Utils::Coercion.coerce_bool(1), 'any non-zero number should be coerced to true'
+
+        [[], {}, '', true, 3.0, Object.new].each do |value|
+          assert Redstruct::Utils::Coercion.coerce_bool(value), 'should be coerced to true'
+        end
+      end
+
+      def test_coerce_array
+        assert_equal [], Redstruct::Utils::Coercion.coerce_array(nil), 'nil should be coerced to empty array'
+
+        array = [1, 2, 3]
+        assert_equal array, Redstruct::Utils::Coercion.coerce_array(array), 'array should be returned as is'
+
+        hash = { a: 1, b: 2 }
+        assert_equal hash.to_a, Redstruct::Utils::Coercion.coerce_array(hash), '#to_a should be coerced to its array representation'
+
+        assert_equal [1], Redstruct::Utils::Coercion.coerce_array(1), 'non #to_a should be coerced to an array containing the given value'
+      end
+    end
+  end
+end

data/test/redstruct/utils/inspectable_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'flexmock/minitest'
+
+module Redstruct
+  module Utils
+    class InspectableTest < Redstruct::Test
+      def test_inspect
+        child = flexmock('test')
+        child.should_receive(:inspect).and_return('child').once
+        other = 'val'
+
+        object = self.class::Test.new(child: child, other: other)
+        assert_equal %(Redstruct::Utils::InspectableTest::Test: child: <child>, other: <"val">), object.inspect, 'should generate the correct inspect string, calling inspect on all values'
+      end
+
+      class Test
+        include Redstruct::Utils::Inspectable
+
+        def initialize(attrs)
+          @attrs = attrs
+        end
+
+        def inspectable_attributes
+          return @attrs
+        end
+      end
+    end
+  end
+end

data/test/redstruct/utils/iterable_test.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Redstruct
+  module Utils
+    class IterableTest < Redstruct::Test
+      def test_to_enum_bad_impl
+        assert_raises(NotImplementedError, 'should fail and raise not implemented on missing implementations') do
+          BadIterator.new.to_enum
+        end
+      end
+
+      def test_each_bad_impl
+        assert_raises(NotImplementedError, 'should fail and raise not implemented on missing implementations') do
+          BadIterator.new.each { |o| o }
+        end
+      end
+
+      def test_each_no_block
+        iterator = self.class::Iterator.new
+        enum = iterator.each # returns an enum
+
+        assert_kind_of Enumerator, enum, 'should return an enumerator when called with no block'
+        assert_equal 0, iterator.iterations, 'should not actually have been called ever yet'
+      end
+
+      def test_each_block
+        iterator = self.class::Iterator.new
+        ones = []
+
+        iterator.each(max_iterations: 2) { |one| ones << one }
+        assert_equal [1, 1], ones, 'should have returned an array of 2 "1"s'
+      end
+
+      # each does not do anything with match or count but pass them on to to_enum, so make sure that this is what we do
+      def test_each_match_count
+        iterator = self.class::Iterator.new
+        _ = iterator.each(match: 'match', count: 1) # returns an enum
+
+        assert_equal 'match', iterator.match, 'should have received the correct match param'
+        assert_equal 1, iterator.count, 'should have received the correct count param'
+      end
+
+      def test_each_max_iterations
+        iterator = self.class::Iterator.new
+        enum = iterator.each(max_iterations: 10)
+
+        assert_equal 10, enum.to_a.size, 'should iterate up to 10 times, therefore containing 10 "1"s in the array'
+        assert_equal 10, iterator.iterations, 'should have iterated exactly 10 times'
+      end
+
+      def test_each_batch_size
+        iterator = self.class::Iterator.new
+        iterator.each(max_iterations: 2, batch_size: 2).each do |ones|
+          assert_equal 2, ones.size, 'should yield in batches of 2 elements'
+          assert_equal [1, 1], ones, 'should yield a list of 2 "1"s'
+        end
+      end
+
+      # Sample class not implementing interface
+      class BadIterator
+        include Redstruct::Utils::Iterable
+      end
+
+      class Iterator
+        include Redstruct::Utils::Iterable
+
+        attr_reader :iterations, :match, :count
+
+        def initialize
+          @iterations = 0
+          @match = nil
+          @count = nil
+        end
+
+        # the idea is to return an infinite stream of 1s, but monitor how the enum was constructed, and how many
+        # iterations were performed, as opposed to creating a mock object
+        def to_enum(match: '*', count: 10)
+          @match = match
+          @count = count
+          @iterations = 0
+
+          return Enumerator.new do |yielder|
+            loop do
+              @iterations += 1 # increment before yielding, since yielding might immediately raise StopIteration, but we'll still have iterated once
+              yielder << 1
+            end
+          end
+        end
+      end
+    end
+  end
+end