start_her 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba090c4bbc338ea1efc647a92b4dc2066fdcf30b
-  data.tar.gz: 8004b2ed21d849d7b8427ebaf786f4a6a8a577d4
+  metadata.gz: 415d14c2937cc1dcedbbf57b32ab27d028c5cded
+  data.tar.gz: 7ff178f1d99806898d1d68cfbf4db0341d8cfc06
 SHA512:
-  metadata.gz: e1baf5d875569065353f05d2c6037bf4fad21a0e29db8378ee710fd5bbbbfdced8fa7470a91d698c7a21a1bda4b7149dcd8b55ef44197e3ea9f2575581c076ef
-  data.tar.gz: d28d6f9dc204c43d2a0e61c17bb7fd685e14246ae9f4621d3934fa71246c84e9777cd546eb4d3d2f39958d4d7077a5d5d1aa68f525e77389cbbbe8cf35ed1bdb
+  metadata.gz: ac9f60be168c0e9d38b00b5c7f41e9168c6a7cc064f0a081164b0b8c8f5aa72248e8704fc9633484b8112bb4a3db4e57b6beb5bca9869ed42f321567337d8620
+  data.tar.gz: b9963c219ddd67f2e51cfdd94d337f19ec2617aa103c85090f2633c068cf5dbe7816b700f7d371fc496196b0bafc7c050a8ffb915f408b2d53a1a43368f399f2

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.0.3
+
+- Realiable push
+- Heartbeat mechanism
+
 ## 0.0.2
 
 - Update gemsupport from `0.4.1` to `0.5.0`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    start_her (0.0.1)
+    start_her (0.0.2)
       gemsupport (~> 0.4)
       logstash-logger (~> 0.15)
       msgpack (~> 0.7)
@@ -18,11 +18,11 @@ GEM
     diff-lcs (1.2.5)
     gemsupport (0.5.0)
     logstash-event (1.2.02)
-    logstash-logger (0.15.1)
+    logstash-logger (0.15.2)
       logstash-event (~> 1.2)
       stud
     method_source (0.8.2)
-    msgpack (0.7.0)
+    msgpack (0.7.1)
     parser (2.2.3.0)
       ast (>= 1.1, < 3.0)
     powerpack (0.1.1)
@@ -31,7 +31,7 @@ GEM
       method_source (~> 0.8.1)
       slop (~> 3.4)
     rainbow (2.0.0)
-    redis (3.2.1)
+    redis (3.2.2)
     redis-namespace (1.5.2)
       redis (~> 3.0, >= 3.0.4)
     rspec (3.3.0)

data/README.md

@@ -1,7 +1,8 @@
 [![Circle CI](https://circleci.com/gh/PredicSis/start_her/tree/master.svg?style=shield)](https://circleci.com/gh/PredicSis/start_her/tree/master)
 
 # StartHer
-Microservices common stuff. Implement redis subscription and logging strategy.
+
+Microservices common stuff. It implements Redis PubSub and Logstash logging strategy.
 
 ## Requirements
 
@@ -29,32 +30,131 @@ StartHer.configure do |config|
   config.logstash_url = 'redis://localhost:6379' # if using default logger in production
 end
 ```
+> See `lib/start_her/configuration.rb` for all configuration variables.
 
 ## Usage
 
+### Publisher
+
+```rb
+class MyClass
+  include StartHer::Publisher
+
+  def do_something
+    # ...
+    reliable_publish('channel_one', 'succeed') # or publish('channel_one', 'succeed') for non persistent events
+  end
+end
+```
+
+By default Redis has no **persistent PubSub**, so a simple mechanism is implemented to attempt to resolve this.
+- Each day a new persistent backlog is created for a given channel
+- Each backlog lives one week according to `StartHer.config.backlog_ttl`
+
+### Subscriber
+
 ```bash
 bundle exec starther ./lib/path/to/subscriber.rb
 ```
 
 **Note**: You need to put your `subscriber.rb` file into the `lib` directory.
 
-## Subscriber class
 
 ```ruby
 class Subscriber
   include StartHer::Subscriber
 
+  # Defaults are defined by StartHer::Subscriber::DEFAULT_OPTS
   subscriber_options channels: ['channel_one', 'channel_two']
+
+  # Customization of error
+  #
+  # This block is not mandatory
   subscriber_error do |error|
     # do something with error
   end
 
+  # Perform an action when Subscriber subscribes on a channel
+  #
+  # This block is not mandatory
+  subscriber_on_psubscribe do |channel|
+    # do something at channel subscription time
+  end
+
+  # Customization of heartbeat response
+  # Each instance of Subscriber listens `hb_ping' channel and sends a response on `hb_pong'
+  # channel for service heartbeat
+  #
+  # This block is not mandatory
+  subscriber_heartbeat do |response|
+    # do something with response
+  end
+
   def process_message(channel, message)
     # your custom stuff here
   end
 end
 ```
 
+Heartbeat ping message format:
+```json
+{
+  "id": "643976ec-fc7c-4cd8-95bb-85a74f1987de",
+  "generated_at": "2015-11-23 10:34:05 UTC",
+  "data": {
+    "id": "058e216d5ce76492b574b39584d0676f359207e05a6a1dd30f238fc5604a66b2",
+    "generated_at": "2015-11-23 10:34:05 UTC",
+    "service_name": "MyPingService",
+    "version": "0.0.1"
+  }
+}
+```
+
+## Testing
+
+StartHer provides a few options for testing your micro-service.
+
+### Setup
+
+StartHer allows you to dynamically configure the testing harness with the following methods:
+```rb
+require 'start_her/testing'
+StartHer::Testing.fake! # fake is the default mode
+# StartHer::Testing.disable!
+
+RSpec.configure do |config|
+  config.before(:each) do
+    StartHer::Testing.clear_stubed_redis
+  end
+end
+```
+
+To query the current state, use the following methods:
+```rb
+StartHer::Testing.fake?
+StartHer::Testing.disable?
+```
+
+### Testing PubSub
+```rb
+require 'start_her/testing'
+
+describe Subscriber do
+  let(:publisher) do
+    ->(chan, msg) { Object.new.extend(StartHer::Publisher).reliable_publish(chan, msg) }
+  end
+  let(:chan) { 'channel_one' }
+  let(:msg) { 'my message' }
+
+  describe '#process_message' do
+    it 'processes message' do
+      expect(subject).to receive(:process_message).with(chan, msg)
+      publisher.call(chan, msg)
+    end
+  end
+end
+```
+
 ## LICENSE
 
 MIT

data/lib/start_her/configuration.rb

@@ -1,11 +1,12 @@
 module StartHer
   class Configuration
-    attr_accessor :redis, :logstash_url
+    attr_accessor :redis, :logstash_url, :backlog_ttl
     attr_writer :logger
 
     def initialize
       @redis = {}
       @logstash_url = ''
+      @backlog_ttl = 60 * 60 * 24 * 7 # 1.week
     end
 
     def logger

data/lib/start_her/heartbeat.rb

@@ -0,0 +1,35 @@
+module StartHer
+  class Heartbeat
+    include StartHer::Publisher
+    include StartHer::Utils
+
+    attr_reader :request, :options
+    attr_accessor :response
+
+    CHANNELS = { in: 'hb_ping', out: 'hb_pong' }
+    DEFAULT_OPTS = { heartbeat: CHANNELS }
+
+    def self.call(request, service_klass, opts = {}, &subscriber_heartbeat_block)
+      new(request, service_klass, opts, &subscriber_heartbeat_block).call
+    end
+
+    def initialize(request, service_klass, opts = {}, &subscriber_heartbeat_block)
+      @request = request
+      @subscriber_heartbeat_block = subscriber_heartbeat_block
+      @options = DEFAULT_OPTS.merge opts
+      @response = {
+        id: msid(service_klass),
+        generated_at: Time.now.utc.to_s,
+        service_name: service_klass.to_s,
+        ping: request['data']
+      }
+      @response[:version] = service_klass::VERSION if defined? service_klass::VERSION
+    end
+
+    def call
+      @subscriber_heartbeat_block.call(response) if @subscriber_heartbeat_block
+      publish(options[:heartbeat][:out],
+        id: SecureRandom.uuid, generated_at: Time.now.utc.to_s, data: response)
+    end
+  end
+end

data/lib/start_her/publisher.rb

@@ -0,0 +1,37 @@
+module StartHer
+  module Publisher
+    include StartHer::RedisClient
+    using StartHer::Refinements
+
+    def publish(channel, message)
+      exponential_backoff({}, ::Redis::BaseConnectionError) do
+        client.publish(channel, message.to_msgpack)
+      end
+    rescue => e
+      StartHer.logger.error e
+      raise e
+    end
+
+    def reliable_publish(channel, message)
+      exponential_backoff({}, ::Redis::BaseConnectionError) do
+        client.multi do |multi|
+          backlog_ttl(channel)
+          multi.lpush(channel.to_current_backlog, message.to_msgpack)
+          multi.publish(channel, message.to_msgpack)
+        end
+      end
+    rescue => e
+      StartHer.logger.error e
+      raise e
+    end
+
+    private
+
+    # Each day a new persistent backlog is created for a given channel
+    # Each backlog lives one week according to `StartHer.config.backlog_ttl'
+    def backlog_ttl(channel)
+      return if client.ttl(channel.to_current_backlog) >= 0
+      client.expire(channel.to_current_backlog, StartHer.config.backlog_ttl)
+    end
+  end
+end

data/lib/start_her/refinements/string.rb

@@ -0,0 +1,9 @@
+module StartHer
+  module Refinements
+    refine String do
+      def to_current_backlog
+        self + ":backlog_#{Time.now.utc.strftime('%Y%m%d')}"
+      end
+    end
+  end
+end

data/lib/start_her/refinements.rb

@@ -0,0 +1 @@
+require 'start_her/refinements/string'

data/lib/start_her/subscriber.rb

@@ -1,8 +1,11 @@
 module StartHer
   module Subscriber
     include StartHer::RedisClient
+    include StartHer::Utils
 
-    DEFAULT_OPTS = { channels: ['*'] }
+    attr_reader :channels, :options, :subscriber_heartbeat_block, :subscriber_on_psubscribe_block
+
+    DEFAULT_OPTS = { channels: ['*'], heartbeat: Heartbeat::CHANNELS }
     DEFAULT_ERROR_BLOCK = lambda do |e|
       StartHer.logger.error e
     end
@@ -12,22 +15,19 @@ module StartHer
     end
 
     module ClassMethods
-      attr_accessor :subscriber_options_hash, :subscriber_error_block
+      attr_accessor :subscriber_options_hash, :subscriber_error_block, :subscriber_heartbeat_block,
+                    :subscriber_on_psubscribe_block
 
       def run!
-        new.tap do |instance|
-          instance.psubscribe(subscriber_options_hash[:channels]) do |channel, message|
-            begin
-              instance.process_message(channel, message)
-            rescue => e
-              if block_given?
-                subscriber_error_block.call(e)
-              else
-                DEFAULT_ERROR_BLOCK.call(e)
-              end
-            end
-          end
-        end
+        new(subscriber_options_hash[:channels]).run!
+      end
+
+      def subscriber_heartbeat(&block)
+        self.subscriber_heartbeat_block = block
+      end
+
+      def subscriber_on_psubscribe(&block)
+        self.subscriber_on_psubscribe_block = block
       end
 
       def subscriber_error(&block)
@@ -39,17 +39,48 @@ module StartHer
       end
     end
 
+    def initialize(channels)
+      @channels = channels
+      @options = self.class.subscriber_options_hash || DEFAULT_OPTS
+      @subscriber_heartbeat_block = self.class.subscriber_heartbeat_block || ->(_response) {}
+      @subscriber_on_psubscribe_block = self.class.subscriber_on_psubscribe_block || ->(_chan) {}
+    end
+
+    def run!
+      psubscribe(channels) do |channel, message|
+        begin
+          process_message(channel, message)
+        rescue => e
+          if block_given?
+            subscriber_error_block.call(e)
+          else
+            DEFAULT_ERROR_BLOCK.call(e)
+          end
+        end
+      end
+    end
+
     # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
     def psubscribe(channels, &block)
       exponential_backoff({}, ::Redis::BaseConnectionError) do
-        client.psubscribe(*channels) do |on|
+        client.psubscribe(options[:heartbeat][:in], *channels) do |on|
           on.psubscribe do |channel, _|
             StartHer.logger.info "PSuscribe on #{channel}"
+
+            resync_messages(client, channel, &block)
+            subscriber_on_psubscribe_block.call(unamespace(channel))
           end
 
           on.pmessage do |_pattern, channel, message|
-            chan = channel.include?(':') ? channel.split(':').last : channel
-            block.call(chan, MessagePack.unpack(message))
+            chan = unamespace(channel)
+            msg = MessagePack.unpack(message)
+
+            if chan == options[:heartbeat][:in]
+              Heartbeat.call(msg, service_klass,
+                heartbeat: options[:heartbeat], &subscriber_heartbeat_block)
+            else
+              block.call(chan, msg)
+            end
           end
         end
       end
@@ -58,5 +89,23 @@ module StartHer
       raise e
     end
     # rubocop:enable Metrics/AbcSize,Metrics/MethodLength
+
+    def resync_messages(client, channel, &block)
+      StartHer.logger.info "Re-synchronize message from #{channel}"
+
+      # Retrieve all backlogs for a given channel
+      client.keys(unamespace(channel) + '*').each do |backlog|
+        # Retrieve all messages for a given backlog
+        client.lrange(backlog, 0, -1).each do |message|
+          block.call(backlog.split(':').first, MessagePack.unpack(message))
+        end
+      end
+    end
+
+    private
+
+    def unamespace(channel)
+      channel.split(':').last
+    end
   end
 end

data/lib/start_her/testing.rb

@@ -0,0 +1,192 @@
+module StartHer
+  module Testing
+    module_function
+
+    attr_accessor :__test_mode
+
+    # rubocop:disable Style/GlobalVars
+    def clear_stubed_redis
+      $stubed_redis.clear_db if $stubed_redis
+    end
+    # rubocop:enable Style/GlobalVars
+
+    # rubocop:disable Style/TrivialAccessors
+    def __set_test_mode(mode)
+      @__test_mode = mode
+    end
+    # rubocop:enable Style/TrivialAccessors
+
+    def disable!
+      __set_test_mode(:disable)
+    end
+
+    def fake!
+      __set_test_mode(:fake)
+    end
+
+    def disable?
+      @__test_mode == :disable
+    end
+
+    def fake?
+      @__test_mode == :fake
+    end
+  end
+  Testing.fake!
+
+  class StubedRedis
+    attr_reader :namespace, :db
+
+    def initialize(namespace:)
+      @namespace = namespace
+      @db = {
+        lists:  {},
+        lists_expiration:  {},
+        channels: {},
+        strings: {}
+      }
+    end
+
+    def clear_db
+      @db = {
+        lists:  {},
+        lists_expiration:  {},
+        channels: {},
+        strings: {}
+      }
+    end
+
+    # Keys command
+    def multi
+      yield self
+    end
+
+    # Keys command
+    def keys(pattern)
+      lists.keys.select { |key| key.match(pattern.gsub '**', '*') }
+    end
+
+    # Keys command
+    def ttl(key)
+      if lists_expiration[key]
+        lists_expiration[key]
+      elsif lists[key] || channels[key]
+        -1
+      else
+        -2
+      end
+    end
+
+    # Keys command
+    def expire(key, ttl)
+      lists_expiration[key] = ttl
+    end
+
+    # String command
+    def get(key)
+      strings[key]
+    end
+
+    # String command
+    def getset(key, value)
+      tmp = strings[key]
+      strings[key] = value
+      tmp
+    end
+
+    def setnx(key, value)
+      if strings[key]
+        0
+      else
+        strings[key] = value
+        1
+      end
+    end
+
+    # List command
+    def lpush(list, data)
+      (lists[fullkey(list)] ||= []).insert(0, data)
+    end
+
+    # List command
+    def lrange(list, min, max)
+      lists[fullkey(list)][min..max]
+    end
+
+    # PubSub command
+    # rubocop:disable Metric/AbcSize,Style/MultilineOperationIndentation
+    def publish(channel, message)
+      return unless channels[fullkey(channel)] && channels[fullkey(channel)].callbacks &&
+        channels[fullkey(channel)].callbacks[:pmessage]
+      channels[fullkey(channel)].callbacks[:pmessage].call(channel, channel, message)
+    end
+    # rubocop:enable Metric/AbcSize,Style/MultilineOperationIndentation
+
+    # PubSub command
+    # rubocop:disable Metrics/AbcSize
+    def psubscribe(*channels)
+      channels.each do |channel|
+        db[:channels][fullkey(channel)] = Subscription.new
+        yield db[:channels][fullkey(channel)]
+        db[:channels][fullkey(channel)].callbacks[:psubscribe].call(channel, 0)
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    class Subscription
+      attr_reader :callbacks
+
+      def initialize
+        @callbacks = {}
+      end
+
+      def psubscribe(&block)
+        callbacks[:psubscribe] = block
+      end
+
+      def pmessage(&block)
+        callbacks[:pmessage] = block
+      end
+    end
+
+    private
+
+    def fullkey(key)
+      if namespace
+        "#{namespace}:#{key}"
+      else
+        key
+      end
+    end
+
+    def lists
+      db[:lists]
+    end
+
+    def lists_expiration
+      db[:lists_expiration]
+    end
+
+    def channels
+      db[:channels]
+    end
+
+    def strings
+      db[:strings]
+    end
+  end
+
+  module RedisClient
+    alias_method :real_client, :client
+    # rubocop:disable Style/GlobalVars
+    def client(options = {})
+      if Testing.fake?
+        options = client_opts(options)
+        $stubed_redis ||= StubedRedis.new(namespace: options[:namespace])
+      else
+        real_client(options)
+      end
+    end
+    # rubocop:enable Style/GlobalVars
+  end
+end

data/lib/start_her/utils.rb

@@ -0,0 +1,28 @@
+module StartHer
+  module Utils
+    def msid(*args)
+      if StartHer.env == 'development'
+        # Easy understanding identifier in development environment
+        "#{args.first || service_klass}:#{object_id}"
+      else
+        Digest::SHA256.hexdigest(fingerprint(*args))
+      end
+    end
+
+    def fingerprint(*args)
+      args ||= []
+      [Socket.gethostname, service_klass].concat(args).map(&:to_s).join('')
+    end
+
+    # If the current class is `MyService::Subscriber'
+    # It returns `MyService' object
+    def service_klass
+      if (klass = Object.const_get(self.class.name.split('::').first)) == StartHer
+        # Find the class name of the caller if `klass' is StartHer
+        binding.receiver.class.name.split('::').first
+      else
+        klass
+      end
+    end
+  end
+end

data/lib/start_her/version.rb

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

data/lib/start_her.rb

@@ -3,6 +3,8 @@ require 'gemsupport'
 require 'start_her/configuration'
 require 'start_her/logger'
 require 'start_her/retry_policies'
+require 'start_her/refinements'
+require 'start_her/utils'
 
 module StartHer
   module_function
@@ -29,4 +31,6 @@ module StartHer
   # Safe loading for stuff that needs MailHer#config
   autoload :RedisClient, 'start_her/redis_client'
   autoload :Subscriber, 'start_her/subscriber'
+  autoload :Publisher, 'start_her/publisher'
+  autoload :Heartbeat, 'start_her/heartbeat'
 end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 require 'start_her'
+require 'start_her/testing'
 
 ENV['RACK_ENV'] ||= 'test'
 
@@ -8,6 +9,10 @@ Dir[File.join(ROOT_SPEC, 'spec', 'support', '**', '*.rb')].each { |f| require f
 RSpec.configure do |config|
   config.include Gemsupport::Error
 
+  config.before(:each) do
+    StartHer::Testing.clear_stubed_redis
+  end
+
   config.order = 'random'
   config.run_all_when_everything_filtered = true
   config.filter_run :focus

data/spec/start_her/configuration_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module StartHer
+  describe Configuration do
+    describe '#initialize' do
+      it 'contains default Redis options' do
+        expect(subject.redis).to eq({})
+      end
+
+      it 'contains default Logstash URL' do
+        expect(subject.logstash_url).to eq('')
+      end
+
+      it 'contains default logger' do
+        expect(subject.logger).to be_a(::LogStashLogger)
+      end
+
+      it 'contains default backlog TTL' do
+        expect(subject.backlog_ttl).to eq(604_800)
+      end
+    end
+  end
+end

data/spec/start_her/heartbeat_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module StartHer
+  describe Heartbeat do
+    include Utils
+
+    let(:uuid) { 'bb8dd4f2-5e3c-420e-9b18-535a335052a2' }
+
+    before do
+      allow(SecureRandom).to receive(:uuid).and_return(uuid)
+    end
+
+    let(:request) { { 'data' => { service: 'ping_service' } } }
+    let(:block) { ->(response) { response[:custom_key] = 'custom' } }
+    subject { Heartbeat.new(request, StartHer, &block) }
+    let(:raw_response) do
+      {
+        id: subject.msid(StartHer),
+        generated_at: Time.now.utc.to_s,
+        service_name: 'StartHer',
+        version: StartHer::VERSION,
+        ping: request['data']
+      }
+    end
+    let(:response) do
+      {
+        id: uuid,
+        generated_at: Time.now.utc.to_s,
+        data: raw_response
+      }
+    end
+    let(:raw_response_2) { raw_response.merge(custom_key: 'custom') }
+    let(:response_2) { response.merge(data: raw_response_2) }
+
+    describe '.call' do
+      it 'publishes the pong message' do
+        expect_any_instance_of(Heartbeat).to receive(:publish)
+          .with('hb_pong', response_2)
+        Heartbeat.call(request, StartHer, &block)
+      end
+    end
+
+    describe '#initialize' do
+      it 'formats response' do
+        expect(subject.response).to eq(raw_response)
+      end
+    end
+
+    describe '#call' do
+      it 'publishes the pong message' do
+        expect(subject).to receive(:publish)
+          .with('hb_pong', response_2)
+        subject.call
+      end
+    end
+  end
+end

data/spec/start_her/publisher_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module StartHer
+  describe Publisher do
+    class TestPublisher
+      include Publisher
+    end
+    subject { TestPublisher.new }
+    let(:channel) { 'channel' }
+    let(:message) { 'message' }
+
+    describe '#publish' do
+      using StartHer::Refinements
+
+      it 'publishes the message' do
+        expect_any_instance_of(StubedRedis).to receive(:publish)
+          .with(channel, message.to_msgpack)
+
+        subject.publish(channel, message)
+      end
+    end
+
+    describe '#reliable_publish' do
+      using StartHer::Refinements
+
+      it 'backlogs the message' do
+        expect_any_instance_of(StubedRedis).to receive(:lpush)
+          .with(channel.to_current_backlog, message.to_msgpack)
+
+        subject.reliable_publish(channel, message)
+      end
+
+      it 'adds TTL on backlog' do
+        subject.reliable_publish(channel, message)
+
+        expect(subject.send(:client).ttl(channel.to_current_backlog)).to eq(604_800)
+      end
+
+      it 'publishes the message' do
+        expect_any_instance_of(StubedRedis).to receive(:publish)
+          .with(channel, message.to_msgpack)
+
+        subject.reliable_publish(channel, message)
+      end
+    end
+  end
+end

data/spec/start_her/redis_client_spec.rb

@@ -7,6 +7,8 @@ module StartHer
     end
 
     subject { RedisClientTest.new }
+    before(:each) { StartHer::Testing.disable! }
+    after(:each) { StartHer::Testing.fake! }
 
     describe '#client' do
       context 'with all options' do

data/spec/start_her/refinements/string_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module StartHer
+  describe 'String refinements' do
+    using Refinements
+
+    describe '#to_current_backlog' do
+      it 'defines backlogs pattern' do
+        expect('channel'.to_current_backlog)
+          .to eq("channel:backlog_#{Time.now.utc.strftime('%Y%m%d')}")
+      end
+    end
+  end
+end

data/spec/start_her/subscriber_spec.rb

@@ -2,22 +2,70 @@ require 'spec_helper'
 
 module StartHer
   describe Subscriber do
-    let(:channels) { ['channel'] }
+    let(:channels) { ['channel.1', 'channel.2'] }
 
     class TestSubscriber
       include Subscriber
 
-      subscriber_options channels: ['channel']
+      subscriber_options channels: ['channel.*']
 
       def process_message(_channel, _message)
       end
     end
+    subject { TestSubscriber.new(['channel.*']) }
 
     describe '.run!' do
       it 'subscribes to channels' do
-        expect_any_instance_of(Subscriber).to receive(:psubscribe).with(channels)
+        expect_any_instance_of(Subscriber).to receive(:psubscribe).with(['channel.*'])
         TestSubscriber.run!
       end
     end
+
+    describe '#resync_message' do
+      let(:message) { 'my message' }
+      let(:publisher) do
+        ->(chan, msg) { Object.new.extend(StartHer::Publisher).reliable_publish(chan, msg) }
+      end
+
+      before do
+        publisher.call(channels.first, message)
+        publisher.call(channels.last, message)
+      end
+
+      it 'resynchronizes messages' do
+        expect(subject).to receive(:process_message)
+          .with(channels.first, message).ordered
+        expect(subject).to receive(:process_message)
+          .with(channels.last, message).ordered
+
+        subject.run!
+      end
+    end
+
+    describe '#psubscribe' do
+      context 'when it receives a heartbeat' do
+        let(:ping) do
+          {
+            'id' => Object.new.extend(StartHer::Utils).msid,
+            'timestamp' => Time.now.utc.to_s,
+            'service' => 'KeepHer'
+          }
+        end
+        let(:publisher) do
+          ->(chan, msg) { Object.new.extend(StartHer::Publisher).publish(chan, msg) }
+        end
+
+        before do
+          subject.run!
+        end
+
+        it 'calls the heartbeat responder' do
+          expect(Heartbeat).to receive(:call)
+            .with(ping, 'StartHer', heartbeat: subject.options[:heartbeat])
+
+          publisher.call(subject.options[:heartbeat][:in], ping)
+        end
+      end
+    end
   end
 end

data/spec/start_her/utils_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module StartHer
+  describe Utils do
+    subject { Object.new.extend(Utils) }
+
+    describe '#msid' do
+      it 'returns a microservice id' do
+        expect(subject.msid('StartHer')).to match(/[a-f0-9]+/)
+      end
+    end
+
+    describe '#fingerprint' do
+      it 'returns a microservice fingerprint' do
+        expect(subject.fingerprint('StartHer'))
+          .to eq([Socket.gethostname, 'Object', 'StartHer'].map(&:to_s).join(''))
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: start_her
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - abourquin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-03 00:00:00.000000000 Z
+date: 2015-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -143,15 +143,26 @@ files:
 - circle.yml
 - lib/start_her.rb
 - lib/start_her/configuration.rb
+- lib/start_her/heartbeat.rb
 - lib/start_her/logger.rb
+- lib/start_her/publisher.rb
 - lib/start_her/redis_client.rb
+- lib/start_her/refinements.rb
+- lib/start_her/refinements/string.rb
 - lib/start_her/retry_policies.rb
 - lib/start_her/subscriber.rb
+- lib/start_her/testing.rb
+- lib/start_her/utils.rb
 - lib/start_her/version.rb
 - spec/spec_helper.rb
+- spec/start_her/configuration_spec.rb
+- spec/start_her/heartbeat_spec.rb
+- spec/start_her/publisher_spec.rb
 - spec/start_her/redis_client_spec.rb
+- spec/start_her/refinements/string_spec.rb
 - spec/start_her/retry_policies_spec.rb
 - spec/start_her/subscriber_spec.rb
+- spec/start_her/utils_spec.rb
 - spec/start_her_spec.rb
 - spec/support/custom_helpers.rb
 - start_her.gemspec
@@ -175,7 +186,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: StartHer