redstream 0.1.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6be694edcad63b15c2e7a6630047080556a412fc1b52f874e4f793e8f07f80b9
-  data.tar.gz: f140446d6fbebc97533de509ff622fe32b121cd89af2c5f0cc2b856f5e820e02
+  metadata.gz: cb01602a9b0e51f896989d59b5e2b16f333c7ea0317f31c5235696bc49145013
+  data.tar.gz: 747f63e94c847be8d371e60098f9348f30531587b821ac019c873c10d51dd766
 SHA512:
-  metadata.gz: 2b38daa5a07f1761fa47340c4d479b974b30937479a6a73897ad8d8e47c9d45328ef976d20b8a74a7cb0488d35985864d162b3adbb66133e56195cb016b09ab4
-  data.tar.gz: 0b625e0f6fea967e69ba319115dd9bfd727b68aec369a83a0842bb39805b0389ebef33bae5cf2559314d54724a9fd28d5a517ab8cbdc88f14db1ec5a601c12ee
+  metadata.gz: 19541261544b2d32168b8e290e402b5c9dedcf54868dee1dbb556bfa5cacf41a091fbff391605a734a6c1bf5eeaf6b33127660b190245166e1340a777c5e433d
+  data.tar.gz: 74426b36ca249b2da61f436f195d6811245038835492321009d063f78226cfdc7e099a4e17fe9910588ebc3f9bc6e21bec8e600959e0e5f8c2e77425ccda7023

data/.github/workflows/test.yml

@@ -0,0 +1,28 @@
+name: test
+on: [push, pull_request]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: ['2.5', '2.6', '2.7', '3.0']
+    services:
+      redis:
+        image: redis
+        ports:
+          - 6379:6379
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - uses: actions/cache@v1
+      id: cache
+      with:
+        path: vendor/bundler
+        key: ${{ hashFiles('Gemfile.lock') }}-${{ matrix.ruby }}
+    - run: |
+        gem install bundler
+        bundle install --path=vendor/bundler
+        bundle exec rspec
+        bundle exec rubocop

data/.rubocop.yml

@@ -1,3 +1,15 @@
+AllCops:
+  NewCops: enable
+
+Gemspec/RequireMFA:
+  Enabled: false
+
+Lint/AssignmentInCondition:
+  Enabled: false
+
+Gemspec/RequiredRubyVersion:
+  Enabled: false
+
 Lint/AmbiguousBlockAssociation:
   Enabled: false
 
@@ -13,9 +25,6 @@ Layout/ArgumentAlignment:
 Layout/FirstArrayElementIndentation:
   EnforcedStyle: consistent
 
-Style/BracesAroundHashParameters:
-  EnforcedStyle: no_braces
-
 Style/PercentLiteralDelimiters:
   Enabled: false
 
@@ -52,7 +61,7 @@ Style/SymbolArray:
 Layout/RescueEnsureAlignment:
   Enabled: false
 
-Metrics/LineLength:
+Layout/LineLength:
   Enabled: false
 
 Metrics/MethodLength:

data/.travis.yml

@@ -1,7 +1,8 @@
 sudo: false
 language: ruby
+cache: bundler
 rvm:
-  - ruby-head
+  - ruby-2.6.2
 before_install:
   - docker-compose up -d
   - sleep 10

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # CHANGELOG
 
+## v0.4.1
+* Fix keyword argument usage of redis 4.5.1 in ruby 3
+
+## v0.4.0
+* Make delay message id params in queue methods optional
+
+## v0.3.0
+* Pipeline deletion of delay messages
+
+## v0.2.0
+* Delete delay messages after queue messages are sent
+
 ## v0.1.1
 * Fix missing queue message in `after_commit on: :destroy`
 

data/README.md

@@ -4,7 +4,7 @@
 **Using redis streams to keep your primary database in sync with secondary
 datastores (e.g. elasticsearch).**
 
-[![Build Status](https://secure.travis-ci.org/mrkamel/redstream.png?branch=master)](http://travis-ci.org/mrkamel/redstream)
+[![Build Status](https://github.com/mrkamel/redstream/workflows/test/badge.svg?branch=master)](https://github.com/mrkamel/redstream/actions?query=workflow%3Atest)
 
 ## Installation
 
@@ -86,9 +86,9 @@ end
 More concretely, `after_save`, `after_touch` and `after_destroy` only write
 "delay" messages to an additional redis stream. Delay message are like any
 other messages, but they get processed by a `Redstream::Delayer` and the
-`Delayer`will wait for some (configurable) delay/time before processing them.
+`Delayer` will wait for some (configurable) delay/time before processing them.
 As the `Delayer` is neccessary to fix inconsistencies, the delay must be at
-least as long as your maxiumum database transaction time. Contrary,
+least as long as your maximum database transaction time. Contrary,
 `after_commit` writes messages to a redis stream from which the messages can
 be fetched immediately to keep the secondary datastores updated in
 near-realtime. The reasoning of all this is simple: usually, i.e. by using only
@@ -97,7 +97,9 @@ any errors occurring in between `after_save` and `after_commit` result in
 inconsistencies between your primary and secondary datastore. By using these
 kinds of "delay" messages triggered by `after_save` and fetched after e.g. 5
 minutes, errors occurring in between `after_save` and `after_commit` can be
-fixed when the delay message get processed.
+fixed when the delay message get processed. Please note that redstream deletes
+delay messages after the messages for immediate retrieval have been
+successfully sent, such that messages will not be processed twice, usually.
 
 Any messages are fetched in batches, such that e.g. elasticsearch can be
 updated using its bulk API. For instance, depending on which elasticsearch ruby

data/lib/redstream/delayer.rb

@@ -48,7 +48,7 @@ module Redstream
     def run_once
       @consumer.run_once do |messages|
         messages.each do |message|
-          seconds_to_sleep = message.message_id.to_f / 1_000 + @delay.to_f - Time.now.to_f
+          seconds_to_sleep = (message.message_id.to_f / 1_000) + @delay.to_f - Time.now.to_f
 
           if seconds_to_sleep > 0
             if @batch.size > 0
@@ -85,11 +85,11 @@ module Redstream
       Redstream.connection_pool.with do |redis|
         redis.pipelined do
           @batch.each do |message|
-            redis.xadd Redstream.stream_key_name(@stream_name), payload: message.fields["payload"]
+            redis.xadd(Redstream.stream_key_name(@stream_name), { payload: message.fields["payload"] })
           end
         end
 
-        redis.xdel Redstream.stream_key_name("#{@stream_name}.delay"), @batch.map(&:message_id)
+        redis.xdel(Redstream.stream_key_name("#{@stream_name}.delay"), @batch.map(&:message_id))
       end
 
       @batch = []

data/lib/redstream/model.rb

@@ -12,6 +12,8 @@ module Redstream
   #   end
 
   module Model
+    IVAR_DELAY_MESSAGE_ID = :@__redstream_delay_message_id__
+
     def self.included(base)
       base.extend(ClassMethods)
     end
@@ -29,11 +31,21 @@ module Redstream
       #   responsible for writing to a redis stream
 
       def redstream_callbacks(producer: Producer.new)
-        after_save { |object| producer.delay(object) if object.saved_changes.present? }
-        after_touch { |object| producer.delay(object) }
-        after_destroy { |object| producer.delay(object) }
-        after_commit(on: [:create, :update]) { |object| producer.queue(object) if object.saved_changes.present? }
-        after_commit(on: :destroy) { |object| producer.queue(object) }
+        after_save    { |object| instance_variable_set(IVAR_DELAY_MESSAGE_ID, producer.delay(object)) if object.saved_changes.present? }
+        after_touch   { |object| instance_variable_set(IVAR_DELAY_MESSAGE_ID, producer.delay(object)) }
+        after_destroy { |object| instance_variable_set(IVAR_DELAY_MESSAGE_ID, producer.delay(object)) }
+
+        after_commit(on: [:create, :update]) do |object|
+          if object.saved_changes.present?
+            producer.queue(object, delay_message_id: instance_variable_get(IVAR_DELAY_MESSAGE_ID))
+            instance_variable_set(IVAR_DELAY_MESSAGE_ID, nil)
+          end
+        end
+
+        after_commit(on: :destroy) do |object|
+          producer.queue(object, delay_message_id: instance_variable_get(IVAR_DELAY_MESSAGE_ID))
+          instance_variable_set(IVAR_DELAY_MESSAGE_ID, nil)
+        end
       end
 
       def redstream_name

data/lib/redstream/producer.rb

@@ -52,11 +52,11 @@ module Redstream
     def bulk(records)
       records_array = Array(records)
 
-      bulk_delay(records_array)
+      delay_message_ids = bulk_delay(records_array)
 
       yield
 
-      bulk_queue(records_array)
+      bulk_queue(records_array, delay_message_ids: delay_message_ids)
     end
 
     # @api private
@@ -64,13 +64,15 @@ module Redstream
     # Writes delay messages to a delay stream in redis.
     #
     # @param records [#to_a] The object/objects that will be updated or deleted
+    #
+    # @return The redis message ids
 
     def bulk_delay(records)
-      records.each_slice(250) do |slice|
+      res = records.each_slice(250).flat_map do |slice|
         Redstream.connection_pool.with do |redis|
           redis.pipelined do
-            slice.map do |object|
-              redis.xadd Redstream.stream_key_name("#{stream_name(object)}.delay"), payload: JSON.dump(object.redstream_payload)
+            slice.each do |object|
+              redis.xadd(Redstream.stream_key_name("#{stream_name(object)}.delay"), { payload: JSON.dump(object.redstream_payload) })
             end
           end
         end
@@ -80,7 +82,7 @@ module Redstream
         redis.wait(@wait, 0) if @wait
       end
 
-      true
+      res
     end
 
     # @api private
@@ -88,13 +90,15 @@ module Redstream
     # Writes messages to a stream in redis for immediate retrieval.
     #
     # @param records [#to_a] The object/objects that will be updated deleted
+    # @param delay_message_ids [#to_a] The delay message ids to delete
 
-    def bulk_queue(records)
-      records.each_slice(250) do |slice|
+    def bulk_queue(records, delay_message_ids: nil)
+      records.each_with_index.each_slice(250) do |slice|
         Redstream.connection_pool.with do |redis|
           redis.pipelined do
-            slice.each do |object|
-              redis.xadd Redstream.stream_key_name(stream_name(object)), payload: JSON.dump(object.redstream_payload)
+            slice.each do |object, index|
+              redis.xadd(Redstream.stream_key_name(stream_name(object)), { payload: JSON.dump(object.redstream_payload) })
+              redis.xdel(Redstream.stream_key_name("#{stream_name(object)}.delay"), delay_message_ids[index]) if delay_message_ids
             end
           end
         end
@@ -107,15 +111,16 @@ module Redstream
     #
     # Writes a single delay message to a delay stream in redis.
     #
-    # @param object The object hat will be updated, deleted, etc.
+    # @param object The object that will be updated, deleted, etc.
+    #
+    # @return The redis message id
 
     def delay(object)
       Redstream.connection_pool.with do |redis|
-        redis.xadd Redstream.stream_key_name("#{stream_name(object)}.delay"), payload: JSON.dump(object.redstream_payload)
+        res = redis.xadd(Redstream.stream_key_name("#{stream_name(object)}.delay"), { payload: JSON.dump(object.redstream_payload) })
         redis.wait(@wait, 0) if @wait
+        res
       end
-
-      true
     end
 
     # @api private
@@ -123,10 +128,14 @@ module Redstream
     # Writes a single message to a stream in redis for immediate retrieval.
     #
     # @param object The object hat will be updated, deleted, etc.
+    # @param delay_message_id The delay message id to delete
 
-    def queue(object)
+    def queue(object, delay_message_id: nil)
       Redstream.connection_pool.with do |redis|
-        redis.xadd Redstream.stream_key_name(stream_name(object)), payload: JSON.dump(object.redstream_payload)
+        redis.pipelined do
+          redis.xadd(Redstream.stream_key_name(stream_name(object)), { payload: JSON.dump(object.redstream_payload) })
+          redis.xdel(Redstream.stream_key_name("#{stream_name(object)}.delay"), delay_message_id) if delay_message_id
+        end
       end
 
       true

data/lib/redstream/version.rb

@@ -1,3 +1,3 @@
 module Redstream
-  VERSION = "0.1.1"
+  VERSION = "0.4.1"
 end

data/spec/redstream/consumer_spec.rb

@@ -80,7 +80,9 @@ RSpec.describe Redstream::Consumer do
 
       all_messages = redis.xrange(Redstream.stream_key_name("products"), "-", "+")
 
-      Redstream::Consumer.new(name: "consumer", stream_name: "products").run_once {}
+      Redstream::Consumer.new(name: "consumer", stream_name: "products").run_once do
+        # nothing
+      end
 
       expect(redis.get(Redstream.offset_key_name(stream_name: "products", consumer_name: "consumer"))).to eq(all_messages.last[0])
     end

data/spec/redstream/delayer_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path("../spec_helper", __dir__)
 RSpec.describe Redstream::Delayer do
   describe "#run_once" do
     it "copies expired messages to their target streams" do
-      redis.xadd Redstream.stream_key_name("target.delay"), payload: JSON.dump(value: "message")
+      redis.xadd(Redstream.stream_key_name("target.delay"), { payload: JSON.dump(value: "message") })
 
       expect(redis.xlen(Redstream.stream_key_name("target"))).to eq(0)
 
@@ -14,9 +14,9 @@ RSpec.describe Redstream::Delayer do
     end
 
     it "delivers and commit before falling asleep" do
-      redis.xadd Redstream.stream_key_name("target.delay"), payload: JSON.dump(value: "message")
+      redis.xadd(Redstream.stream_key_name("target.delay"), { payload: JSON.dump(value: "message") })
       sleep 3
-      redis.xadd Redstream.stream_key_name("target.delay"), payload: JSON.dump(value: "message")
+      redis.xadd(Redstream.stream_key_name("target.delay"), { payload: JSON.dump(value: "message") })
 
       thread = Thread.new do
         Redstream::Delayer.new(stream_name: "target", delay: 1).run_once
@@ -33,7 +33,7 @@ RSpec.describe Redstream::Delayer do
     end
 
     it "does not copy not yet expired messages" do
-      redis.xadd Redstream.stream_key_name("target.delay"), payload: JSON.dump(value: "message")
+      redis.xadd(Redstream.stream_key_name("target.delay"), { payload: JSON.dump(value: "message") })
 
       thread = Thread.new do
         Redstream::Delayer.new(stream_name: "target", delay: 2).run_once

data/spec/redstream/model_spec.rb

@@ -3,19 +3,36 @@ require File.expand_path("../spec_helper", __dir__)
 RSpec.describe Redstream::Model do
   describe "after_save" do
     it "adds a delay message after_save" do
-      expect { create(:product) }.to change { redis.xlen(Redstream.stream_key_name("products.delay")) }
+      Product.transaction do
+        expect { create(:product) }.to change { redis.xlen(Redstream.stream_key_name("products.delay")) }
+      end
+    end
+
+    it "assigns the delay message id" do
+      Product.transaction do
+        expect(create(:product).instance_variable_get(Redstream::Model::IVAR_DELAY_MESSAGE_ID)).to be_present
+      end
     end
 
     it "adds the correct payload for the delay message" do
-      product = create(:product)
+      Product.transaction do
+        product = create(:product)
 
-      expect(redis.xrange(Redstream.stream_key_name("products.delay"), "-", "+").first[1]).to eq("payload" => JSON.dump(product.redstream_payload))
+        expect(redis.xrange(Redstream.stream_key_name("products.delay"), "-", "+").first[1]).to eq("payload" => JSON.dump(product.redstream_payload))
+      end
     end
 
     it "adds a queue message after_save on commit" do
       expect { create(:product) }.to change { redis.xlen(Redstream.stream_key_name("products")) }
     end
 
+    it "deletes the delay message on commit" do
+      product = create(:product)
+
+      expect(redis.xlen(Redstream.stream_key_name("products.delay"))).to eq(0)
+      expect(product.instance_variable_get(Redstream::Model::IVAR_DELAY_MESSAGE_ID)).to be_nil
+    end
+
     it "does not add a delay message after_save if there are no changes" do
       product = create(:product)
 
@@ -33,35 +50,73 @@ RSpec.describe Redstream::Model do
     it "adds a delay message after touch" do
       product = create(:product)
 
-      expect { product.touch }.to change { redis.xlen(Redstream.stream_key_name("products.delay")) }
+      Product.transaction do
+        expect { product.touch }.to change { redis.xlen(Redstream.stream_key_name("products.delay")) }
+      end
+    end
+
+    it "assigns the delay message id" do
+      product = create(:product)
+
+      Product.transaction do
+        product.touch
+
+        expect(product.instance_variable_get(Redstream::Model::IVAR_DELAY_MESSAGE_ID)).to be_present
+      end
     end
 
     it "sets the correct payload for the delay message" do
       product = create(:product)
-      product.touch
 
-      expect(redis.xrange(Redstream.stream_key_name("products.delay"), "-", "+").last[1]).to eq("payload" => JSON.dump(product.redstream_payload))
+      Product.transaction do
+        product.touch
+
+        expect(redis.xrange(Redstream.stream_key_name("products.delay"), "-", "+").last[1]).to eq("payload" => JSON.dump(product.redstream_payload))
+      end
     end
 
-    it "adds a queue message after touch commit" do
+    it "adds a queue message after touch on commit" do
       product = create(:product)
 
       expect { product.touch }.to change { redis.xlen(Redstream.stream_key_name("products")) }
     end
+
+    it "deletes the delay message after touch on commit" do
+      product = create(:product)
+      product.touch
+
+      expect(redis.xlen(Redstream.stream_key_name("products.delay"))).to eq(0)
+      expect(product.instance_variable_get(Redstream::Model::IVAR_DELAY_MESSAGE_ID)).to be_nil
+    end
   end
 
   describe "after_destroy" do
     it "adds a delay message after destroy" do
       product = create(:product)
 
-      expect { product.destroy }.to change { redis.xlen(Redstream.stream_key_name("products.delay")) }
+      Product.transaction do
+        expect { product.destroy }.to change { redis.xlen(Redstream.stream_key_name("products.delay")) }
+      end
+    end
+
+    it "assigns the delay message id" do
+      product = create(:product)
+
+      Product.transaction do
+        product.destroy
+
+        expect(product.instance_variable_get(Redstream::Model::IVAR_DELAY_MESSAGE_ID)).to be_present
+      end
     end
 
     it "sets the correct payload for the delay message" do
       product = create(:product)
-      product.destroy
 
-      expect(redis.xrange(Redstream.stream_key_name("products.delay"), "-", "+").last[1]).to eq("payload" => JSON.dump(product.redstream_payload))
+      Product.transaction do
+        product.destroy
+
+        expect(redis.xrange(Redstream.stream_key_name("products.delay"), "-", "+").last[1]).to eq("payload" => JSON.dump(product.redstream_payload))
+      end
     end
 
     it "adds a queue messages after destroy on commit" do
@@ -69,5 +124,13 @@ RSpec.describe Redstream::Model do
 
       expect { product.destroy }.to change { redis.xlen(Redstream.stream_key_name("products")) }.by(1)
     end
+
+    it "deletes the delay message after destroy on commit" do
+      product = create(:product)
+      product.destroy
+
+      expect(redis.xlen(Redstream.stream_key_name("products.delay"))).to eq(0)
+      expect(product.instance_variable_get(Redstream::Model::IVAR_DELAY_MESSAGE_ID)).to be_nil
+    end
   end
 end

data/spec/redstream/producer_spec.rb

@@ -10,6 +10,17 @@ RSpec.describe Redstream::Producer do
       expect { Redstream::Producer.new.queue(product) }.to change { redis.xlen(stream_key_name) }.by(1)
       expect(redis.xrange(stream_key_name, "-", "+").last[1]).to eq("payload" => JSON.dump(product.redstream_payload))
     end
+
+    it "deletes the delay message when given" do
+      product = create(:product)
+
+      producer = Redstream::Producer.new
+
+      id = producer.delay(product)
+      producer.queue(product, delay_message_id: id)
+
+      expect(redis.xlen(Redstream.stream_key_name("products.delay"))).to eq(0)
+    end
   end
 
   describe "#delay" do
@@ -31,6 +42,57 @@ RSpec.describe Redstream::Producer do
     end
   end
 
+  describe "#bulk" do
+    it "adds bulk delay messages for scopes" do
+      products = create_list(:product, 2)
+
+      stream_key_name = Redstream.stream_key_name("products")
+
+      expect(redis.xlen("#{stream_key_name}.delay")).to eq(0)
+
+      Redstream::Producer.new.bulk(Product.all) do
+        messages = redis.xrange("#{stream_key_name}.delay", "-", "+").last(2).map { |message| message[1] }
+
+        expect(messages).to eq([
+          { "payload" => JSON.dump(products[0].redstream_payload) },
+          { "payload" => JSON.dump(products[1].redstream_payload) }
+        ])
+      end
+    end
+
+    it "adds bulk queue messages for scopes" do
+      products = create_list(:product, 2)
+
+      stream_key_name = Redstream.stream_key_name("products")
+
+      expect do
+        Redstream::Producer.new.bulk(Product.all) do
+          # nothing
+        end
+      end.to change { redis.xlen(stream_key_name) }.by(2)
+
+      messages = redis.xrange(stream_key_name, "-", "+").last(2).map { |message| message[1] }
+
+      expect(messages).to eq([
+        { "payload" => JSON.dump(products[0].redstream_payload) },
+        { "payload" => JSON.dump(products[1].redstream_payload) }
+      ])
+    end
+
+    it "deletes the delay messages after the queue messages have been sent" do
+      products = create_list(:product, 2)
+      producer = Redstream::Producer.new
+
+      other_delay_message_id = producer.delay(create(:product))
+
+      producer.bulk(products) do
+        expect(redis.xlen(Redstream.stream_key_name("products.delay"))).to eq(3)
+      end
+
+      expect(redis.xrange(Redstream.stream_key_name("products.delay"), "-", "+").map(&:first)).to eq([other_delay_message_id])
+    end
+  end
+
   describe "#bulk_queue" do
     it "adds bulk queue messages for scopes" do
       products = create_list(:product, 2)
@@ -46,6 +108,18 @@ RSpec.describe Redstream::Producer do
         { "payload" => JSON.dump(products[1].redstream_payload) }
       ])
     end
+
+    it "deletes the delay messages after the queue messages have been sent" do
+      products = create_list(:product, 2)
+      producer = Redstream::Producer.new
+
+      delay_message_ids = producer.bulk_delay(products)
+      other_delay_message_id = producer.delay(create(:product))
+
+      producer.bulk_queue(products, delay_message_ids: delay_message_ids)
+
+      expect(redis.xrange(Redstream.stream_key_name("products.delay"), "-", "+").map(&:first)).to eq([other_delay_message_id])
+    end
   end
 
   describe "#bulk_delay" do
@@ -64,7 +138,7 @@ RSpec.describe Redstream::Producer do
       ])
     end
 
-    it "should resepect wait for delay" do
+    it "should respect wait for delay" do
       create(:product)
 
       stream_key_name = Redstream.stream_key_name("products.delay")

data/spec/redstream/trimmer_spec.rb

@@ -4,11 +4,11 @@ RSpec.describe Redstream::Trimmer do
   describe "#run_once" do
     it "trims a stream to the minimum committed id" do
       ids = Array.new(4) do |i|
-        redis.xadd Redstream.stream_key_name("default"), payload: JSON.dump(value: "message#{i}")
+        redis.xadd(Redstream.stream_key_name("default"), { payload: JSON.dump(value: "message#{i}") })
       end
 
-      redis.set Redstream.offset_key_name(stream_name: "default", consumer_name: "consumer1"), ids[1]
-      redis.set Redstream.offset_key_name(stream_name: "default", consumer_name: "consumer2"), ids[2]
+      redis.set(Redstream.offset_key_name(stream_name: "default", consumer_name: "consumer1"), ids[1])
+      redis.set(Redstream.offset_key_name(stream_name: "default", consumer_name: "consumer2"), ids[2])
 
       trimmer = Redstream::Trimmer.new(
         interval: 5,

data/spec/redstream_spec.rb

@@ -34,7 +34,7 @@ RSpec.describe Redstream do
     it "returns the stream's size" do
       expect(Redstream.stream_size("products")).to eq(0)
 
-      redis.xadd("redstream:stream:products", key: "value")
+      redis.xadd("redstream:stream:products", { key: "value" })
 
       expect(Redstream.stream_size("products")).to eq(1)
     end
@@ -44,8 +44,8 @@ RSpec.describe Redstream do
     it "returns the stream's max id" do
       expect(Redstream.max_stream_id("products")).to be_nil
 
-      _id1 = redis.xadd("redstream:stream:products", key: "value")
-      id2 = redis.xadd("redstream:stream:products", key: "value")
+      _id1 = redis.xadd("redstream:stream:products", { key: "value" })
+      id2 = redis.xadd("redstream:stream:products", { key: "value" })
 
       expect(Redstream.max_stream_id("products")).to eq(id2)
     end
@@ -55,8 +55,8 @@ RSpec.describe Redstream do
     it "returns the consumer's max id" do
       expect(Redstream.max_consumer_id(stream_name: "products", consumer_name: "consumer")).to be_nil
 
-      _id1 = redis.xadd("redstream:stream:products", key: "value")
-      id2 = redis.xadd("redstream:stream:products", key: "value")
+      _id1 = redis.xadd("redstream:stream:products", { key: "value" })
+      id2 = redis.xadd("redstream:stream:products", { key: "value" })
 
       Redstream::Consumer.new(name: "consumer", stream_name: "products").run_once do |messages|
         # nothing

data/spec/spec_helper.rb

@@ -17,7 +17,7 @@ ActiveRecord::Base.connection.execute "DROP TABLE IF EXISTS products"
 
 ActiveRecord::Base.connection.create_table :products do |t|
   t.string :title
-  t.timestamps
+  t.timestamps null: false
 end
 
 class Product < ActiveRecord::Base

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redstream
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.4.1
 platform: ruby
 authors:
 - Benjamin Vetter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-20 00:00:00.000000000 Z
+date: 2021-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -242,6 +242,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/test.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".travis.yml"
@@ -288,7 +289,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.15
 signing_key: 
 specification_version: 4
 summary: Using redis streams to keep your primary database in sync with secondary