redstruct 0.1.7 → 0.2.0

data/test/redstruct/hash_test.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Redstruct
+  class HashTest < Redstruct::Test
+    def setup
+      super
+      @factory = create_factory
+      @hash = @factory.hashmap('hash')
+    end
+
+    def test_brackets
+      value = SecureRandom.hex(4)
+      assert_nil @hash['test'], 'should return nil for non-existent element'
+      @hash['test'] = value
+      assert_equal value, @hash['test'], 'should return the correct value'
+    end
+
+    def test_get_one
+      value = SecureRandom.hex(4)
+      assert_nil @hash.get('a'), 'should return nil for non-existent element'
+      @hash['a'] = value
+      assert_equal value, @hash.get('a'), 'should return correct value'
+    end
+
+    def test_get_multiple
+      hash = { 'a' => SecureRandom.hex(4), 'b' => SecureRandom.hex(4) }
+      assert_equal({}, @hash.get('a', 'b'), 'should return a empty hash for non existent keys')
+      @hash.update(hash)
+      assert_equal hash, @hash.get('a', 'b'), 'should return the correct hash for requested keys'
+    end
+
+    def test_set
+      value = SecureRandom.hex(4)
+      assert_nil @hash['a'], 'should return nothing'
+      @hash.set('a', value)
+      assert_equal value, @hash['a'], 'should return the correct value'
+    end
+
+    def test_set_overwrite
+      initial = SecureRandom.hex(4)
+      updated = SecureRandom.hex(4)
+
+      @hash.set('a', initial)
+      @hash.set('a', updated, overwrite: false)
+      assert_equal initial, @hash['a'], 'should not have overwritten the initial value'
+      @hash.set('a', updated, overwrite: true)
+      assert_equal updated, @hash['a'], 'should have overwritten the initial value'
+    end
+
+    def test_update
+      initial = { 'a' => SecureRandom.hex(4), 'b' => SecureRandom.hex(4) }
+      assert @hash.empty?, 'initial should be empty'
+      @hash.update(initial)
+      assert_equal initial, @hash.to_h, 'should have been updated accordingly'
+
+      updated = { 'a' => SecureRandom.hex(4), 'c' => SecureRandom.hex(4) }
+      @hash.update(updated)
+      assert_equal initial.merge(updated), @hash.to_h, 'should have been updated correctly'
+    end
+
+    def test_empty?
+      assert @hash.empty?, 'should initially be empty'
+      @hash['a'] = 1
+      refute @hash.empty?, 'should not be empty with one element'
+    end
+
+    def test_remove
+      @hash['a'] = 'a'
+      assert @hash.key?('a'), 'should contain something for key a'
+      @hash.remove('a')
+      refute @hash.key?('a'), 'should not contain the key a anymore'
+    end
+
+    def test_key?
+      refute @hash.key?('a'), 'should not contain the key a initially'
+      @hash['a'] = 1
+      assert @hash.key?('a'), 'should now contain the key a'
+    end
+
+    def test_increment
+      assert_equal 1, @hash.increment('a'), 'initial increment should return 1'
+      assert_equal 2, @hash.increment('a'), 'second increment should return 2'
+      assert_equal 3.5, @hash.increment('a', by: 1.5), 'should return 3.5'
+    end
+
+    def test_decrement
+      assert_equal(-1, @hash.decrement('a'), 'initial decrement should return -1')
+      assert_equal(-2, @hash.decrement('a'), 'second decrement should return -2')
+      assert_equal(-3.5, @hash.decrement('a', by: 1.5), 'should return -3.5')
+    end
+
+    def test_keys
+      hash = { 'a' => 'b', 'b' => 'a' }
+      assert_equal [], @hash.keys, 'should initially return no keys initially'
+      @hash.update(hash)
+      assert_equal hash.keys, @hash.keys, 'should return the same keys after an update'
+    end
+
+    def test_values
+      hash = { 'a' => 'b', 'b' => 'a' }
+      assert_equal [], @hash.values, 'should initially return no values initially'
+      @hash.update(hash)
+      assert_equal hash.values, @hash.values, 'should return the same values after an update'
+    end
+
+    def test_to_h
+      hash = { 'a' => 'b', 'b' => 'a' }
+      assert_equal({}, @hash.to_h, 'should be an empty hash initially')
+      @hash.update(hash)
+      assert_equal hash, @hash.to_h, 'should return the whole hash as a standard ruby hash'
+    end
+
+    def test_size
+      hash = { 'a' => 'b', 'b' => 'a' }
+      assert_equal 0, @hash.size, 'should be an empty hash initially'
+      @hash.update(hash)
+      assert_equal 2, @hash.size, 'should return the correct amount of pairs'
+    end
+
+    def test_each
+      hash = { 'a' => 'b', 'b' => 'a' }
+      keys = hash.keys
+      values = hash.values
+
+      @hash.update(hash)
+      @hash.each do |key, value|
+        keys.delete(key)
+        values.delete(value)
+        assert_equal hash[key], value, 'should return the correct key-value-pair'
+      end
+
+      assert_empty keys, 'should have no more keys left to match'
+      assert_empty values, 'should have no more values to match'
+    end
+  end
+end

data/test/redstruct/list_test.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Redstruct
+  class ListTest < Redstruct::Test
+    def setup
+      super
+      @factory = create_factory
+      @list = @factory.list('list')
+    end
+
+    def test_clear
+      @list.append(1, 2, 3)
+      refute @list.empty?, 'should not be empty'
+      @list.clear
+      assert @list.empty?, 'should be empty after a clear operation'
+    end
+
+    def test_empty?
+      assert @list.empty?, 'should be initially empty'
+      @list.push(1)
+      refute @list.empty?, 'should not be empty anymore'
+    end
+
+    def test_brackets
+      (0..2).each do |i|
+        value = SecureRandom.hex(4)
+        assert_nil @list[i], 'should return nothing initially'
+        @list[i] = value
+        assert_equal value, @list[i], 'should return the correct value'
+      end
+    end
+
+    def test_insert_single
+      initial = SecureRandom.hex(4)
+      assert_raises(Redis::CommandError, 'should fail (out of bounds)') do
+        @list.insert(initial, 1)
+      end
+
+      assert @list.insert(initial, 0), 'should insert correctly first element'
+      assert_equal initial, @list[0]
+
+      assert @list.insert(initial, 1), 'should insert correctly second element'
+      assert_equal initial, @list[1]
+
+      value = SecureRandom.hex(4)
+      assert @list.insert(value, 1), 'should insert correctly between both'
+      assert_equal value, @list[1], 'should have new value at index 1'
+      assert_equal initial, @list[0], 'should still have correct value as index 0'
+      assert_equal initial, @list[2], 'should still have correct value as index 2'
+    end
+
+    def test_append
+      values = %w[1 2]
+      assert_equal values.size, @list.append(*values), 'should have successfully appended'
+      assert_equal values, @list.to_a, 'should have the correct values stored'
+
+      appended = %w[3 4]
+      expected = values + appended
+      assert_equal expected.size, @list.append(*appended), 'should have successfully appended'
+      assert_equal expected, @list.to_a, 'should have the correct values stored'
+    end
+
+    def test_append_exists
+      values = %w[1 2]
+      refute @list.append(*values, exists: true), 'should not append since the list does not exist'
+
+      @list[0] = 'a'
+      assert @list.append(*values, exists: true), 'should have appended once the list existed'
+      assert_equal %w[a 1 2], @list.to_a, 'should contain correct values'
+    end
+
+    def test_append_max
+      values = %w[1 2]
+      assert @list.append(*values, max: 2), 'should append all elements'
+      assert_equal values, @list.to_a, 'should append all elements'
+
+      assert_equal 2, @list.append(3, max: 2), 'should still return the actual size of the list'
+      assert_equal values, @list.to_a, 'should not have appended the last element'
+    end
+
+    def test_prepend
+      values = %w[1 2]
+      assert_equal values.size, @list.prepend(*values), 'should have successfully prepended'
+      assert_equal values, @list.to_a, 'should have the correct values stored'
+
+      prepended = %w[3 4]
+      expected = prepended + values
+      assert_equal expected.size, @list.prepend(*prepended), 'should have successfully prepended'
+      assert_equal expected, @list.to_a, 'should have the correct values stored'
+    end
+
+    def test_prepend_exists
+      values = %w[1 2]
+      refute @list.prepend(*values, exists: true), 'should not prepend since the list does not exist'
+
+      @list[0] = 'a'
+      assert @list.prepend(*values, exists: true), 'should have prepended once the list existed'
+      assert_equal %w[1 2 a], @list.to_a, 'should contain correct values'
+    end
+
+    def test_prepend_max
+      values = %w[1 2]
+      assert @list.prepend(*values, max: 2), 'should prepend all elements'
+      assert_equal values, @list.to_a, 'should append all elements'
+
+      assert_equal 2, @list.prepend(3, max: 2), 'should still return the actual size of the list'
+      assert_equal %w[3 1], @list.to_a, 'should not have prepended the last element'
+    end
+
+    def test_pop_single
+      assert @list.empty?, 'should be empty initially'
+      @list.append('a', 'b')
+
+      assert_equal 'b', @list.pop, 'should have popped the last element'
+      assert_equal %w[a], @list.to_a, 'should have only one element left'
+    end
+
+    def test_pop_multiple
+      assert @list.empty?, 'should be empty initially'
+      @list.append('a', 'b', 'c')
+
+      assert_equal %w[b c], @list.pop(2), 'should have popped the last 2 elements'
+      assert_equal %w[a], @list.to_a, 'should have only one element left'
+    end
+
+    # TODO: not the ideal way to test this, but what would be a better way?
+    def test_pop_timeout
+      assert @list.empty?, 'should be empty initially'
+
+      Thread.new do
+        sleep 0.2
+        @list.push('a', 'b')
+      end
+
+      assert_equal 'b', @list.pop(timeout: 3), 'should have returned the correct element'
+      assert_raises(ArgumentError, 'should not allow timeout with size > 1') do
+        @list.pop(5, timeout: 1)
+      end
+    end
+
+    def test_shift_single
+      assert @list.empty?, 'should be empty initially'
+      @list.append('a', 'b')
+
+      assert_equal 'a', @list.shift, 'should have shifted the first element'
+      assert_equal %w[b], @list.to_a, 'should have only one element left'
+    end
+
+    def test_shift_multiple
+      assert @list.empty?, 'should be empty initially'
+      @list.append('a', 'b', 'c')
+
+      assert_equal %w[a b], @list.shift(2), 'should have shifted the first 2 elements'
+      assert_equal %w[c], @list.to_a, 'should have only one element left'
+    end
+
+    # TODO: not the ideal way to test this, but what would be a better way?
+    def test_shift_timeout
+      assert @list.empty?, 'should be empty initially'
+
+      Thread.new do
+        sleep 0.2
+        @list.push('a', 'b')
+      end
+
+      assert_equal 'a', @list.shift(timeout: 3), 'should have returned the correct element'
+      assert_raises(ArgumentError, 'should not allow timeout with size > 1') do
+        @list.shift(5, timeout: 1)
+      end
+    end
+
+    def test_remove_left
+      @list.append('a', 'b', 'a', 'b', 'a', 'b')
+      assert_equal 1, @list.remove('a', count: 1), 'should remove 1 element equal to the value from left'
+      assert_equal %w[b a b a b], @list.to_a, 'should have removed first a only'
+      assert_equal 2, @list.remove('b', count: 2), 'should remove both bs'
+      assert_equal %w[a a b], @list.to_a, 'should have only the last b left'
+    end
+
+    def test_remove_right
+      @list.append('a', 'b', 'a', 'b', 'a', 'b')
+      assert_equal 1, @list.remove('a', count: -1), 'should remove 1 element equal to the value from the right'
+      assert_equal %w[a b a b b], @list.to_a, 'should have removed last a only'
+      assert_equal 2, @list.remove('b', count: -2), 'should remove the last 2 bs'
+      assert_equal %w[a b a], @list.to_a, 'should have only the middle b left'
+    end
+
+    def test_remove_all
+      @list.append('a', 'b', 'b', 'a')
+      assert_equal 2, @list.remove('a', count: 0), 'should remove all elements equal to the given value'
+      assert_equal %w[b b], @list.to_a, 'should have only the other values left'
+    end
+
+    def test_size
+      assert_equal 0, @list.size, 'should have size 0 initially'
+      @list.push(1, 2)
+      assert_equal 2, @list.size, 'should have the same amount that was pushed'
+    end
+
+    def test_to_a
+      expected = %w[a b c]
+      assert_equal [], @list.to_a, 'should return empty array initially'
+      @list.push(*expected)
+      assert_equal expected, @list.to_a, 'should return what was pushed'
+    end
+
+    def test_slice_positive
+      values = %w[a b c d e f g]
+      assert_equal [], @list.slice, 'should return nothing initially'
+      @list.push(*values)
+
+      assert_equal values.slice(0, 1), @list.slice(start: 0, length: 1), 'should return the same as Array#slice'
+      assert_equal values.slice(2, 3), @list.slice(start: 2, length: 3), 'should return the same as Array#slice'
+    end
+
+    def test_slice_negative
+      values = %w[a b c d e f g]
+      assert_equal [], @list.slice, 'should return nothing initially'
+      @list.push(*values)
+
+      assert_equal values, @list.slice(start: 0, length: -1), 'should return the same as Array#slice'
+      assert_equal values[2..-2], @list.slice(start: 2, length: -2), 'should return the same as Array#slice'
+    end
+
+    # Blocking is not tested as I'm still unsure what's a good way to test it
+    def test_popshift
+      assert_raises(ArgumentError, 'should not be able to push on something that is not a list') do
+        @list.popshift(2)
+      end
+
+      values = %w[a b c]
+      list2 = @factory.list('list2')
+
+      @list.push(*values)
+      assert_equal 'c', @list.popshift(list2), 'should have popped the last element'
+      assert_equal %w[c], list2.to_a, 'should contain the popped element'
+
+      assert_equal 'b', @list.popshift(list2), 'should have popped the last element'
+      assert_equal %w[b c], list2.to_a, 'should contain the new popped element as its first element'
+    end
+  end
+end

data/test/redstruct/lock_test.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Redstruct
+  class LockTest < Redstruct::Test
+    def setup
+      super
+      @factory = create_factory
+    end
+
+    def test_initialize
+      resource = 'resource'
+      lock = create(resource)
+
+      assert_equal resource, lock.resource, 'should be locking the correct resource'
+      assert_nil lock.token, 'should not hold any tokens at the moment'
+      assert_equal Redstruct::Lock::DEFAULT_EXPIRY, lock.expiry, 'should have the default expiry'
+      assert_equal Redstruct::Lock::DEFAULT_TIMEOUT, lock.timeout, 'should have the default timeout'
+
+      expiry = rand
+      timeout = rand(10)
+      lock = create(timeout: timeout, expiry: expiry)
+      assert_equal expiry, lock.expiry, 'should have the correct expiry'
+      assert_equal timeout, lock.timeout, 'should have the correct timeout'
+
+      lock = create(timeout: Float::INFINITY)
+      assert_equal 0, lock.timeout, 'should have a timeout of 0 when given infinity'
+    end
+
+    def test_acquire
+      resource = 'resource'
+      lock = create(resource)
+
+      f1 = Fiber.new do
+        lock1 = create(resource)
+        Fiber.yield lock1.acquire
+        Fiber.yield lock1.release
+        Fiber.yield lock1.acquire
+      end
+
+      f2 = Fiber.new do
+        lock2 = create(resource)
+        Fiber.yield lock2.acquire
+        Fiber.yield lock2.acquire
+        Fiber.yield lock2.release
+      end
+
+      assert f1.resume, 'should have successfully acquired the lock'
+      refute f2.resume, 'should have failed to acquire the lock'
+      assert f1.resume, 'should have released the lock'
+      assert f2.resume, 'should have acquired the lock'
+      refute f1.resume, 'should have failed to acquire the lock'
+      refute lock.acquire, 'should have failed to acquire the lock'
+      assert f2.resume, 'should have released the lock'
+      assert lock.acquire, 'should have successfully acquired the lock'
+      assert lock.release, 'should have released the lock'
+    end
+
+    # To avoid actually blocking, we simply test that the method is called
+    # without actually calling it. The non-blocking tests should be
+    # sufficient for the actual locking logic.
+    def test_acquire_blocking
+      resource = 'resource'
+      lock = create(resource, expiry: 1)
+      lock2 = create(resource, timeout: 1)
+
+      tokens = lock2.instance_eval { @tokens }
+      ensure_command_called(tokens, :brpop, { timeout: lock2.timeout }, allow: false).and_return(nil)
+
+      assert lock.acquire, 'should have acquired the lock'
+      refute lock2.acquire
+      refute lock2.release, 'should not release something not acquired'
+      assert lock.release, 'should release what was acquired'
+    end
+
+    def test_release
+      lock = create
+      refute lock.release, 'should not be able to release if nothing was acquired'
+      assert lock.acquire, 'should acquire the lock'
+      refute_nil lock.token, 'should have some token'
+      assert lock.release, 'should release the acquired lock'
+      assert_nil lock.token, 'should have no token once released'
+    end
+
+    def test_locked
+      resource = 'resource'
+      lock = create(resource)
+      lock2 = create(resource)
+
+      assert lock2.acquire, 'should be able to acquire free lock'
+      refute(lock.locked { raise 'should not have been able to lock!' })
+      assert lock2.release, 'should be able to release acquired lock'
+
+      executed = false
+      assert(lock.locked { executed = true }, 'should have acquired the lock')
+      assert executed, 'should have executed inner block'
+      assert_nil lock.token, 'should have released previous token'
+      refute lock.release, 'should not be able to release lock since it was already released'
+    end
+
+    private
+
+    def create(resource = nil, **options)
+      return @factory.lock(resource || SecureRandom.hex(4), **options)
+    end
+  end
+end

data/test/redstruct/script_test.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Redstruct
+  class ScriptTest < Redstruct::Test
+    def setup
+      super
+      @value = @@counter.incr
+      @code = "return #{@value}"
+      @factory = create_factory
+      @script = @factory.script(@code)
+    end
+
+    def test_initialize
+      assert_equal @code, @script.script, 'should have correct script'
+      assert_equal Digest::SHA1.hexdigest(@code), @script.sha1, 'should have correct sha1'
+      assert_equal @factory.connection, @script.connection, 'should have correct connection'
+
+      script = @factory.script(@code, sha1: 'dummy sha1')
+      assert_equal 'dummy sha1', script.sha1, 'should have accepted our dummy sha1 even if incorrect'
+    end
+
+    def test_script=
+      lua = 'return -1'
+      old_sha1 = @script.sha1
+      new_sha1 = Digest::SHA1.hexdigest(lua)
+
+      @script.script = lua
+      assert_equal lua, @script.script, 'should have correctly assigned the new code'
+      assert_equal new_sha1, @script.sha1, 'should have updated the sha1'
+      refute_equal old_sha1, @script.sha1, 'should have a different sha1 now'
+    end
+
+    def test_exists?
+      refute @script.exists?, 'should not initially exists'
+      @script.load
+      assert @script.exists?, 'script should exists after loading it'
+    end
+
+    def test_load
+      refute @script.exists?, 'should not initially exists'
+      assert_equal @script.sha1, @script.load, 'should return the sha1 of the script'
+      assert @script.exists?, 'should exist after load'
+    end
+
+    def test_eval
+      refute @script.exists?, 'should not exist initially'
+      assert_equal @value, @script.eval, "should execute the script (which returns #{@value})"
+      assert @script.exists?, 'should exist after first evaluation'
+    end
+  end
+end