meeseeker 0.0.2 → 0.0.3pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7bfa088e3bfa5279abd98d16d7831bed68ace5e45bd859c599d3eed83cd267f8
-  data.tar.gz: 6acf83bf0d19993d0de12bf8735fd1b2c8d749b3ea0ffbbaa0afdd6e90893379
+  metadata.gz: '058271f9eb089b43a706275a96a06f4b87ac8bbf96b2404a2bbd7c239c2882fc'
+  data.tar.gz: f5f73c53bc34c485b46d94e887249ce65dc3114ee0cf60189849a28786656a27
 SHA512:
-  metadata.gz: dd2e6ed985f066effb91c07e07e1309959e62ea6b718db3bfcceef753e3a745888388d088150a86cdf0742d91bdecf3538dd9c7b4953073ad9f17b9767dd4ffb
-  data.tar.gz: d69123020a72b424b695017f48c48b9f246e64650722b35723cf33c31fbc8444517f09425854dbf9331461973999e24ffd3193752cf89b0958d339d2cddedcd9
+  metadata.gz: dfb048376f1a0e17bed91a44116d2718a99127eeba0d770ae50d535eead02d298b1105401385b76e06124e94a3e777b7ecf8bd188a4a4c7c6bc3cff635774835
+  data.tar.gz: 74ac56d7d083c6f1e2d5da9496079bf670f4bd12d15122044ac295fe6b75b05c50402cc0d969ab902f54dc264ffa574ee6a78f89a60fb6c9f2597c6db484e417

data/README.md

@@ -80,16 +80,119 @@ To ignore virtual operations (useful if the node doesn't enable `get_ops_in_bloc
 MEESEEKER_INCLUDE_VIRTUAL=false meeseeker sync
 ```
 
+Normally, block headers are added to the `steem:block` channel.  This requires one additional API call for each block.  If you don't need block headers, you can configure the `steem:block` channel to only publish with the `block_num`:
+
+```bash
+MEESEEKER_INCLUDE_BLOCK_HEADER=false meeseeker sync
+```
+
 Normally, keys stay on redis for 24 hours.  If you want to change this behavior, use `MEESEEKER_EXPIRE_KEYS` and specify the new value in seconds, for example:
 
 ```bash
 MEESEEKER_EXPIRE_KEYS=10 meeseeker sync
 ```
 
+If you never want the keys to expire (not recommended), set
+`MEESEEKER_EXPIRE_KEYS` to -1:
+
+```bash
+MEESEEKER_EXPIRE_KEYS=-1 meeseeker sync
+```
+
 ### Usage
 
 When `meeseeker sync` starts for the first time, it initializes from the last irreversible block number.  If the sync is interrupted, it will resume from the last block sync'd unless that block is older than `MEESEEKER_EXPIRE_KEYS` in which case it will skip to the last irreversible block number.
 
+#### Using `SUBSCRIBE`
+
+For `redis-cli`, please see: https://redis.io/topics/pubsub
+
+Channels available for `meeseeker`:
+
+* `steem:block`
+* `steem:transaction`
+* `steem:op:vote`
+* `steem:op:comment`
+* `steem:op:comment_options`
+* `steem:op:whatever` (replace "whatever" with the op you want)
+* `steem:op:custom_json:whatever` (if enabled, replace "whatever" with the `custom_json.id` you want)
+
+As mentioned in the first `whatever` example, for ops, [all operation types](https://developers.steem.io/apidefinitions/broadcast-ops) can be subscribed to as channels, including virtual operations, if enabled.
+
+In the second `whatever` example, for `custom_json.id`, if you want to subscribe to the `follow` channel, use `steem:op:custom_json:follow`.  Or if you want to subscribe to the `sm_team_reveal` channel, use `steem:op:custom_json:follow`.  The `custom_json.id` channels are not enabled by default.  To enable it, set the `MEESEEKER_PUBLISH_OP_CUSTOM_ID` to `true` (see example below).
+
+For example, from `redis-cli`, if we wanted to stream block numbers:
+
+```bash
+$ redis-cli
+127.0.0.1:6379> subscribe steem:block
+Reading messages... (press Ctrl-C to quit)
+1) "subscribe"
+2) "steem:block"
+3) (integer) 1
+1) "message"
+2) "steem:block"
+3) "{\"block_num\":29861068,\"previous\":\"01c7a4cb4424b4dc0cb0cc72fd36b1644f8aeba5\",\"timestamp\":\"2019-01-28T20:55:03\",\"witness\":\"ausbitbank\",\"transaction_merkle_root\":\"a318bb82625bd78af8d8b506ccd4f53116372c8e\",\"extensions\":[]}"
+1) "message"
+2) "steem:block"
+3) "{\"block_num\":29861069,\"previous\":\"01c7a4cc1bed060876cab57476846a91568a9f8a\",\"timestamp\":\"2019-01-28T20:55:06\",\"witness\":\"followbtcnews\",\"transaction_merkle_root\":\"834e05d40b9666e5ef50deb9f368c63070c0105b\",\"extensions\":[]}"
+1) "message"
+2) "steem:block"
+3) "{\"block_num\":29861070,\"previous\":\"01c7a4cd3bbf872895654765faa4409a8e770e91\",\"timestamp\":\"2019-01-28T20:55:09\",\"witness\":\"timcliff\",\"transaction_merkle_root\":\"b2366ce9134d627e00423b28d33cc57f1e6e453f\",\"extensions\":[]}"
+```
+
+In addition to general op channels, there's an additional channel for `custom_json.id`.  This option must be enabled:
+
+```bash
+MEESEEKER_PUBLISH_OP_CUSTOM_ID=true meeseeker sync
+```
+
+Which allows subscription to specific `id` patterns:
+
+```
+$ redis-cli
+127.0.0.1:6379> subscribe steem:op:custom_json:sm_team_reveal
+Reading messages... (press Ctrl-C to quit)
+1) "subscribe"
+2) "steem:op:custom_json:sm_team_reveal"
+3) (integer) 1
+1) "message"
+2) "steem:op:custom_json:sm_team_reveal"
+3) "{\"key\":\"steem:29890790:bcfa68d9be10b3587d81039b85fd0536ddeddffb:0:custom_json\"}"
+1) "message"
+2) "steem:op:custom_json:sm_team_reveal"
+3) "{\"key\":\"steem:29890792:3f3b921ec6706bcd259f5cc6ac922dc59bbe2de5:0:custom_json\"}"
+1) "message"
+2) "steem:op:custom_json:sm_team_reveal"
+3) "{\"key\":\"steem:29890792:4ceca16dd114b1851140086a82a5fb3a6eb6ec42:0:custom_json\"}"
+1) "message"
+2) "steem:op:custom_json:sm_team_reveal"
+3) "{\"key\":\"steem:29890792:00930eff76b3f0af8ed7215e88cf351cc671490b:0:custom_json\"}"
+1) "message"
+2) "steem:op:custom_json:sm_team_reveal"
+3) "{\"key\":\"steem:29890799:01483bd252ccadb05f546051bb20a4ba9afea243:0:custom_json\"}"
+```
+
+A `ruby` application can subscribe to a channel as well, using the `redis` gem:
+
+```ruby
+require 'redis'
+
+url = 'redis://127.0.0.1:6379/0'
+ctx = Redis.new(url: url)
+
+Redis.new(url: url).subscribe('steem:op:comment') do |on|
+  on.message do |channel, message|
+    payload = JSON[message]
+    comment = JSON[ctx.get(payload['key'])]
+    
+    puts comment['value']
+  end
+end
+```
+
+Many other clients are supported: https://redis.io/clients
+
 #### Using `SCAN`
 
 From the redis manual:
@@ -100,6 +203,10 @@ From the redis manual:
 
 See: https://redis.io/commands/scan
 
+Keep in mind that `SCAN` requires pagination to get a complete result.  Redis implements pagination using a cursor based iterator.
+
+See: https://redis.io/commands/scan#scan-basic-usage
+
 Once your sync has started, you can begin doing queries against redis, for example, in the `redis-cli`:
 
 ```bash

data/Rakefile

@@ -73,3 +73,135 @@ task reset: [:check_schema] do
     puts ' nothing to drop.'
   end
 end
+
+namespace :verify do
+  desc 'Verifies transactions land where they should.'
+  task :block_org, [:max_blocks] do |t, args|
+    defined? Thread.report_on_exception and Thread.report_on_exception = true
+    
+    max_blocks = args[:max_blocks]
+    node_url = ENV.fetch('MEESEEKER_NODE_URL', 'https://api.steemit.com')
+    database_api = Steem::DatabaseApi.new(url: node_url)
+    until_block_num = nil
+    
+    Thread.new do
+      job = Meeseeker::BlockFollowerJob.new
+      mode = ENV.fetch('MEESEEKER_STREAM_MODE', 'head').to_sym
+      until_block_num = if !!max_blocks
+        database_api.get_dynamic_global_properties do |dgpo|
+          case mode
+          when :head then dgpo.head_block_number
+          when :irreversible then dgpo.last_irreversible_block_num
+          else; abort "Unknown block mode: #{mode}"
+          end
+        end + max_blocks.to_i
+      end
+      
+      loop do
+        begin
+          job.perform(mode: mode, until_block_num: until_block_num)
+        rescue => e
+          puts e.inspect
+          sleep 5
+        end
+        
+        break # success
+      end
+      
+      puts 'Background sync finished ...'
+    end
+    
+    begin
+      block_api = Steem::BlockApi.new(url: node_url)
+      block_channel = 'steem:block'
+      redis_url = ENV.fetch('MEESEEKER_REDIS_URL', 'redis://127.0.0.1:6379/0')
+      subscription = Redis.new(url: redis_url)
+      ctx = Redis.new(url: redis_url)
+      timeout = (max_blocks).to_i * 3
+      
+      subscribe_mode, subscribe_args = if timeout > 0
+        [:subscribe_with_timeout, [timeout, [block_channel]]]
+      else
+        [:subscribe, [[block_channel]]]
+      end
+      
+      subscription.send(subscribe_mode, *subscribe_args) do |on|
+        on.subscribe do |channel, subscriptions|
+          puts "Subscribed to ##{channel} (subscriptions: #{subscriptions})"
+        end
+        
+        on.message do |channel, message|
+          payload = JSON[message]
+          block_num = payload['block_num']
+          expected_witness = payload['witness']
+          next_block_num = block_num + 1
+          
+          if !!max_blocks
+            if block_num >= until_block_num
+              subscription.unsubscribe
+              next
+            end
+          end
+            
+          while ctx.keys("steem:#{next_block_num}:*").size == 0
+            # This ensures at least the next block has been indexed before
+            # proceeding.
+            
+            puts "Waiting for block: #{next_block_num} ..."
+            sleep 6
+          end
+          
+          database_api.get_dynamic_global_properties do |dgpo|
+            (block_num - dgpo.last_irreversible_block_num).tap do |offset|
+              # This will block all channel callbacks until the first known block
+              # is irreversible.  After that, the offsets should mostly go
+              # negative.
+              
+              sleep offset * 3 if offset > 0
+            end
+          end
+          
+          # In theory, we should have all the keys using this pattern.
+          keys = ctx.keys("steem:#{block_num}:*")
+          
+          # If we have all the keys, we should also have all transaction ids.
+          expected_ids = keys.map { |k| k.split(':')[2] }.uniq
+          expected_ids -= [Meeseeker::VIRTUAL_TRX_ID]
+          
+          actual_ids, actual_witness = block_api.get_block(block_num: block_num) do |result|
+            block = result.block
+            [block.transaction_ids, block.witness]
+          end
+          
+          # We do an intersection to make sure there's no difference between
+          # the two copies, regardless of order, as opposed to just checking that
+          # the lengths match.
+          
+          (actual_ids & expected_ids).tap do |intersection|
+            all_sizes = [intersection.size, expected_ids.size, actual_ids.size]
+            puts 'intersection: %d; expected: %d; actual: %d' % all_sizes
+            
+            if all_sizes.min != all_sizes.max
+              puts "Expected witness: #{expected_witness}; actual witness: #{actual_witness}"
+              puts "Expected transaction ids:"
+              puts expected_ids
+              puts "Actual transaction ids:"
+              puts actual_ids
+              
+              puts "actual_ids minus expected:"
+              puts actual_ids - expected_ids
+              puts "expected_ids minus actual:"
+              puts expected_ids - actual_ids
+              
+              exit(-1)
+            end
+          end
+        end
+        
+        on.unsubscribe do |channel, subscriptions|
+          puts "Unsubscribed from ##{channel} (subscriptions: #{subscriptions})"
+        end
+      end
+    end
+  end
+end

data/bin/meeseeker

@@ -24,7 +24,7 @@ when 'sync'
   
   loop do; begin
     Rake::Task['sync'].invoke(ARGV[1])
-  rescue Steem::BaseError => e
+  rescue => e
     puts "Error: #{e.inspect}"
     backoff = [backoff, max_backoff].min
     sleep backoff *= 2

data/lib/meeseeker/block_follower_job.rb

@@ -1,23 +1,98 @@
 module Meeseeker
   class BlockFollowerJob
     def perform(options = {})
-      stream = Steem::Stream.new(url: Meeseeker.node_url, mode: Meeseeker.stream_mode)
-      database_api = Steem::DatabaseApi.new(url: Meeseeker.node_url)
+      block_api = Steem::BlockApi.new(url: Meeseeker.node_url)
       redis = Meeseeker.redis
+      last_key_prefix = nil
+      trx_index = 0
+      current_block_num = nil
+      block_transactions = []
+      
+      stream_operations(options) do |op, trx_id, block_num|
+        begin
+          current_key_prefix = "steem:#{block_num}:#{trx_id}"
+          
+          if current_key_prefix == last_key_prefix
+            trx_index += 1
+          else
+            if !!last_key_prefix
+              n, b, t = last_key_prefix.split(':')
+              transaction_payload = {
+                block_num: b.to_i,
+                transaction_id: t,
+                transaction_num: block_transactions.size
+              }
+              
+              block_transactions << trx_id unless trx_id == VIRTUAL_TRX_ID
+              redis.publish('steem:transaction', transaction_payload.to_json)
+            end
+            last_key_prefix = "steem:#{block_num}:#{trx_id}"
+            trx_index = 0
+          end
+          
+          op_type = op.type.split('_')[0..-2].join('_')
+          key = "#{current_key_prefix}:#{trx_index}:#{op_type}"
+          puts key
+        end
+        
+        redis.set(key, op.to_json)
+        redis.expire(key, Meeseeker.expire_keys) unless Meeseeker.expire_keys == -1
+        
+        if current_block_num != block_num
+          block_transactions = []
+          block_payload = {
+            block_num: block_num
+          }
+          
+          if Meeseeker.include_block_header
+            block_api.get_block_header(block_num: block_num) do |result|
+              block_payload = block_payload.merge(result.header.to_h)
+            end
+          end
+          
+          redis.set(LAST_BLOCK_NUM_KEY, block_num)
+          redis.publish('steem:block', block_payload.to_json)
+          current_block_num = block_num
+        end
+        
+        redis.publish("steem:op:#{op_type}", {key: key}.to_json)
+        
+        if Meeseeker.publish_op_custom_id
+          if %w(custom custom_binary custom_json).include? op_type
+            id = (op["value"]["id"] rescue nil).to_s
+            
+            if id.size > 0
+              redis.publish("steem:op:#{op_type}:#{id}", {key: key}.to_json)
+            end
+          end
+        end
+      end
+    end
+  private
+    def stream_operations(options = {}, &block)
+      redis = Meeseeker.redis
+      last_block_num = nil
+      mode = options.delete(:mode) || Meeseeker.stream_mode
+      options[:include_virtual] ||= Meeseeker.include_virtual
       
       if !!options[:at_block_num]
         last_block_num = options[:at_block_num].to_i
       else
+        database_api = Steem::DatabaseApi.new(url: Meeseeker.node_url)
         last_block_num = redis.get(LAST_BLOCK_NUM_KEY).to_i + 1
         
         database_api.get_dynamic_global_properties do |dgpo|
-          block_num = case Meeseeker.stream_mode
+          block_num = case mode
           when :head then dgpo.head_block_number
           when :irreversible then dgpo.last_irreversible_block_num
-          else; abort "Unknown stream mode: #{Meeseeker.stream_mode}"
+          else; abort "Unknown stream mode: #{mode}"
           end
           
-          if block_num - last_block_num > Meeseeker.expire_keys / 3
+          if Meeseeker.expire_keys == -1
+            last_block_num = [last_block_num, block_num].max
+            
+            puts "Sync from: #{last_block_num}"
+          elsif block_num - last_block_num > Meeseeker.expire_keys / 3
             last_block_num = block_num
             
             puts 'Starting new sync.'
@@ -30,46 +105,17 @@ module Meeseeker
         end
       end
       
-      options = {
-        at_block_num: last_block_num,
-        include_virtual: Meeseeker.include_virtual
-      }
-      
-      if !!last_block_num
-        puts options.to_json
-      end
-      
-      last_key_prefix = nil
-      trx_index = 0
-      current_block_num = nil
-      
-      stream.operations(options) do |op, trx_id, block_num|
-        current_key_prefix = "steem:#{block_num}:#{trx_id}"
+      begin
+        stream_options = {url: Meeseeker.node_url, mode: mode}
+        options = options.merge(at_block_num: last_block_num)
         
-        if current_key_prefix == last_key_prefix
-          trx_index += 1
-        else
-          if !!last_key_prefix
-            n, b, t = last_key_prefix.split(':')
-            redis.publish('steem:transaction', {block_num: b.to_i, trx_id: t}.to_json)
+        Steem::Stream.new(stream_options).tap do |stream|
+          puts "Stream begin: #{stream_options.to_json}; #{options.to_json}"
+          
+          stream.operations(options) do |op, trx_id, block_num|
+            yield op, trx_id, block_num
           end
-          last_key_prefix = "steem:#{block_num}:#{trx_id}"
-          trx_index = 0
         end
-        
-        op_type = op.type.split('_')[0..-2].join('_')
-        key = "#{current_key_prefix}:#{trx_index}:#{op_type}"
-        puts key
-        redis.set(key, op.to_json)
-        redis.expire(key, Meeseeker.expire_keys)
-        
-        if current_block_num != block_num
-          redis.set(LAST_BLOCK_NUM_KEY, block_num)
-          redis.publish('steem:block', {block_num: block_num}.to_json)
-          current_block_num = block_num
-        end
-        
-        redis.publish("steem:op:#{op_type}", {key: key}.to_json)
       end
     end
   end

data/lib/meeseeker/version.rb

@@ -1,3 +1,3 @@
 module Meeseeker
-  VERSION = '0.0.2'
+  VERSION = '0.0.3pre1'
 end

data/lib/meeseeker.rb

@@ -7,13 +7,17 @@ require 'meeseeker/block_follower_job'
 module Meeseeker
   LAST_BLOCK_NUM_KEY = 'steem:meeseeker:last_block_num'
   BLOCKS_PER_DAY = 28800
+  VIRTUAL_TRX_ID = '0000000000000000000000000000000000000000'
   @redis = Redis.new(url: ENV.fetch('MEESEEKER_REDIS_URL', 'redis://127.0.0.1:6379/0'))
   @node_url = ENV.fetch('MEESEEKER_NODE_URL', 'https://api.steemit.com')
   @stream_mode = ENV.fetch('MEESEEKER_STREAM_MODE', 'head').downcase.to_sym
   @include_virtual = ENV.fetch('MEESEEKER_INCLUDE_VIRTUAL', 'true').downcase == 'true'
+  @include_block_header = ENV.fetch('MEESEEKER_INCLUDE_BLOCK_HEADER', 'true').downcase == 'true'
+  @publish_op_custom_id = ENV.fetch('MEESEEKER_PUBLISH_OP_CUSTOM_ID', 'false').downcase == 'true'
   @expire_keys = ENV.fetch('MEESEEKER_EXPIRE_KEYS', BLOCKS_PER_DAY * 3).to_i
   
   extend self
 
-  attr_accessor :redis, :node_url, :expire_keys, :stream_mode, :include_virtual
+  attr_accessor :redis, :node_url, :expire_keys, :stream_mode, :include_virtual,
+    :include_block_header, :publish_op_custom_id
 end

data/meeseeker.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.description = 'If you have multiple applications that need to perform actions as operations occur, `meeseeker` will allow your apps to each perform actions for specific operations without each app having to streaming the entire blockchain.'
   s.authors = ['Anthony Martin']
   s.email = ['meeseeker@martin-studio.com,']
-  s.files = Dir['bin/**/*', 'lib/**/*', 'Gemfile', 'LICENSE', 'Rakefile', 'README.md', 'meeseeker.gemspec']
+  s.files = Dir['bin/**/*', 'lib/**/*', 'test/**/*', 'Gemfile', 'LICENSE', 'Rakefile', 'README.md', 'meeseeker.gemspec']
   s.test_files = Dir['test/**/*']
   s.executables = Dir['bin/*'].map{ |f| File.basename(f) }
   s.homepage = 'https://rubygems.org/gems/meeseeker'
@@ -21,6 +21,11 @@ Gem::Specification.new do |s|
 
   # Ruby Make (interprets the Rakefile DSL).
   s.add_development_dependency 'rake', '~> 12.3', '>= 12.3.1'
+  s.add_development_dependency 'minitest', '~> 5.10', '>= 5.10.3'
+  s.add_development_dependency 'minitest-line', '~> 0.6', '>= 0.6.4'
+  s.add_development_dependency 'minitest-proveit', '~> 1.0', '>= 1.0.0'
+  s.add_development_dependency 'simplecov', '~> 0.15', '>= 0.15.1'
+  s.add_development_dependency 'pry', '~> 0.11', '>= 0.11.3'
 
   s.add_dependency 'redis', '~> 4.1', '>= 4.1.0'
   s.add_dependency 'steem-mechanize', '~> 0.0', '>= 0.0.5'

data/test/meeseeker/meeseeker_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+require 'rake'
+
+module Meeseeker
+  class MeeseekerTest < Meeseeker::Test
+    def setup
+      gem_dir = File.expand_path("..", File.dirname(__FILE__))
+      $LOAD_PATH.unshift gem_dir
+
+      pwd = Dir.pwd
+      Dir.chdir(gem_dir)
+      Rake.application.init
+      Rake.application.load_rakefile
+      Dir.chdir(pwd)
+    end
+    
+    def test_verify_block_org
+      max_blocks = 30 # must be at least 15 to get past irreversible
+      if !!Meeseeker.redis.get(Meeseeker::LAST_BLOCK_NUM_KEY)
+        fail "Found existing keys.  Please use 'rake reset' to enable this test."
+      end
+      
+      assert Rake::Task['verify:block_org'].invoke(max_blocks)
+      assert Rake::Task['reset'].invoke
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'simplecov'
+
+SimpleCov.start
+SimpleCov.merge_timeout 3600
+
+require 'meeseeker'
+require 'minitest/autorun'
+require 'minitest/line/describe_track'
+require 'minitest/hell'
+require 'minitest/proveit'
+require 'pry'
+
+class Minitest::Test
+  parallelize_me!
+end
+
+class Meeseeker::Test < MiniTest::Test
+  defined? prove_it! and prove_it!
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: meeseeker
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3pre1
 platform: ruby
 authors:
 - Anthony Martin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-28 00:00:00.000000000 Z
+date: 2019-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -30,6 +30,106 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 12.3.1
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.10.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.10.3
+- !ruby/object:Gem::Dependency
+  name: minitest-line
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+- !ruby/object:Gem::Dependency
+  name: minitest-proveit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.15.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.15.1
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.3
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -109,6 +209,8 @@ files:
 - lib/meeseeker/block_follower_job.rb
 - lib/meeseeker/version.rb
 - meeseeker.gemspec
+- test/meeseeker/meeseeker_test.rb
+- test/test_helper.rb
 homepage: https://rubygems.org/gems/meeseeker
 licenses:
 - CC0-1.0
@@ -125,9 +227,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.7
@@ -135,4 +237,6 @@ signing_key:
 specification_version: 4
 summary: Redis based block follower is an efficient way for multiple apps to stream
   the Steem Blockchain.
-test_files: []
+test_files:
+- test/test_helper.rb
+- test/meeseeker/meeseeker_test.rb