captainu-tincan 0.7.0

data/spec/failure_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Tincan::Failure do
+  let(:dummy) do
+    instance = DummyClass.new
+    instance.name = 'Some Idiot'
+    instance
+  end
+
+  # let(:message_fixture) { IO.read('spec/fixtures/message.json').strip }
+  # let(:message) { Tincan::Message.from_json(message_fixture) }
+  let(:failure) { Tincan::Failure.new(100, 'some_queue') }
+  let(:fixture) { IO.read('spec/fixtures/failure.json').strip }
+
+  describe :initialize do
+    it 'takes an message object, sets attempt count to 0' do
+      expect(failure).to be_a(Tincan::Failure)
+      expect(failure.attempt_count).to eq(0)
+      expect(failure.failed_at).to be_a(DateTime)
+    end
+  end
+
+  describe :attempt_after do
+    it 'takes failed date/time and extends it by a number of seconds' do
+      failure.attempt_count = 1
+      expected = Rational(10, 86400)
+      expect(failure.attempt_after).to eq(failure.failed_at + expected)
+    end
+
+    it 'extends the next attempt based on attempt_count' do
+      failure.attempt_count = 2
+      expected = Rational(20, 86400)
+      expect(failure.attempt_after).to eq(failure.failed_at + expected)
+    end
+  end
+
+  describe :to_json do
+    it 'converts the failure to a serialized JSON string' do
+      expect(failure.to_json).to be_a(String)
+      expect { JSON.parse(failure.to_json) }.to_not raise_error
+    end
+  end
+
+  describe :from_json do
+    let(:from_json) { Tincan::Failure.from_json(fixture) }
+
+    it 'deserializes an object from a JSON string' do
+      expect(from_json).to be_a(Tincan::Failure)
+    end
+
+    it 'sets everything up properly' do
+      expect(from_json.message_id).to eq('55')
+      expect(from_json.attempt_count).to eq(1)
+      expect(from_json.failed_at).to be_a(DateTime)
+      expect(from_json.queue_name).to eq('data:object_one:client:messages')
+    end
+  end
+end

data/spec/fixtures/failure.json

@@ -0,0 +1 @@
+{"failed_at":"2014-06-02T09:30:47-05:00","attempt_count":1,"message_id":"55","queue_name":"data:object_one:client:messages"}

data/spec/fixtures/message.json

@@ -0,0 +1 @@
+{"object_name":"dummy_class","change_type":"create","object_data":{"name":"Some Idiot"},"published_at":"2014-06-02T09:43:36-05:00"}

data/spec/message_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Tincan::Message do
+  let(:dummy) do
+    instance = DummyClass.new
+    instance.name = 'Some Idiot'
+    instance
+  end
+
+  let(:message) do
+    Tincan::Message.new do |m|
+      m.object_name = 'dummy_class'
+      m.object_data = { name: dummy.name }
+      m.change_type = :create
+    end
+  end
+  let(:fixture) { IO.read('spec/fixtures/message.json').strip }
+
+  describe :initialize do
+    it 'takes an object and a change type symbol' do
+      expect(message).to be_a(Tincan::Message)
+    end
+
+    it 'fails with an invalid symbol type' do
+      process = -> { Tincan::Message.new(DummyClass.new, :bork) }
+      expect(process).to raise_error(ArgumentError)
+    end
+
+    it 'stores these as properties' do
+      dummy = DummyClass.new
+      msg = Tincan::Message.new do |m|
+        m.object_name = 'dummy_class'
+        m.object_data = { name: dummy.name }
+        m.change_type = :create
+      end
+      expect(msg.object_name).to eq('dummy_class')
+      expect(msg.change_type).to eq(:create)
+      expect(msg.object_data).to eq(name: dummy.name)
+      expect(msg.published_at).to be_a(DateTime)
+    end
+  end
+
+  describe :to_json do
+    it 'converts the message to a serialized JSON string' do
+      expect(message.to_json).to be_a(String)
+      expect { JSON.parse(message.to_json) }.to_not raise_error
+    end
+
+    it 'includes the proper data' do
+      fixture.slice!('"2014-06-02T09:43:36-05:00"}')
+      expect(message.to_json).to start_with(fixture)
+    end
+  end
+
+  describe :from_json do
+    let(:from_json) { Tincan::Message.from_json(fixture) }
+    it 'deserializes an object from a JSON string' do
+      expect(from_json).to be_a(Tincan::Message)
+    end
+
+    it 'sets everything up properly' do
+      expect(from_json.object_name).to eq('dummy_class')
+      expect(from_json.change_type).to eq(:create)
+      expect(from_json.object_data).to eq('name' => 'Some Idiot')
+      expect(from_json.published_at).to be_a(DateTime)
+    end
+  end
+end

data/spec/receiver_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+# A test helper for handling messages.
+class Handler
+  attr_accessor :data, :context
+end
+
+describe Tincan::Receiver do
+  let(:fixture) { IO.read('spec/fixtures/message.json').strip }
+  let(:receiver) { Tincan::Receiver.new(options) }
+  let(:redis) { ::Redis.new(host: options[:redis_host]) }
+  let(:handler_one_alpha) { Handler.new }
+  let(:handler_one_beta) { Handler.new }
+  let(:handler_two_alpha) { Handler.new }
+  let(:exception_handler) { Handler.new }
+  let(:options) do
+    {
+      redis_host: 'localhost',
+      redis_port: 6379,
+      client_name: 'bork',
+      namespace: 'data',
+      logger: ::Logger.new(STDOUT),
+      listen_to: {
+        object_one: [
+          -> (data) { handler_one_alpha.data = data },
+          -> (data) { handler_one_beta.data = data }
+          ],
+        object_two: [-> (data) { handler_two_alpha.data = data }]
+      },
+      on_exception: (lambda do |ex, context|
+        exception_handler.data = ex
+        exception_handler.context = context
+      end)
+    }
+  end
+
+  before { redis.flushdb }
+
+  describe :lifecycle do
+    it 'can be setup with a block' do
+      instance = Tincan::Receiver.new do |config|
+        options.keys.each do |key|
+          config.send("#{key}=", options[key])
+        end
+      end
+
+      options.keys.each do |key|
+        expect(instance.send(key)).to eq(options[key])
+      end
+    end
+
+    it 'can be setup with an options hash' do
+      options.keys.each do |key|
+        expect(receiver.send(key)).to eq(options[key])
+      end
+    end
+  end
+
+  describe :related_objects do
+    it 'memoizes a redis client' do
+      expect(receiver.redis_client).to be_a(Redis)
+      expect(receiver.redis_client.client.host).to eq(receiver.redis_host)
+      expect(receiver.redis_client.client.port).to eq(receiver.redis_port)
+    end
+  end
+
+  describe :transactional_methods do
+    describe :register do
+      it 'registers itself as a receiver for supplied channels' do
+        receiver.register
+        receivers = redis.smembers('data:object_one:receivers')
+        expect(receivers).to include(receiver.client_name)
+      end
+
+      it 'returns self' do
+        expect(receiver.register).to eq(receiver)
+      end
+    end
+
+    describe :store_failure do
+      let(:failure) do
+        Tincan::Failure.new('55', 'data:object_one:client:messages')
+      end
+
+      it 'stores a message ID in a specialized failures list' do
+        failure.attempt_count = 1
+        receiver.store_failure(failure)
+        failures = redis.lrange('data:object_one:client:failures', 0, -1)
+        expected = '"attempt_count":1,"message_id":"55","queue_name":'
+        expected << '"data:object_one:client:messages"}'
+        expect(failures.first).to include(expected)
+      end
+
+      it 'returns the message count in the failures queue' do
+        result = receiver.store_failure(failure)
+        expect(result).to eq(1)
+
+        result = receiver.store_failure(failure)
+        expect(result).to eq(2)
+
+        failure.message_id = 100
+        result = receiver.store_failure(failure)
+        expect(result).to eq(3)
+      end
+    end
+  end
+
+  describe :message_handling_methods do
+    describe :handle_message_for_object do
+      it 'iterates through the channel dict and calls lambdas' do
+        msg = OpenStruct.new(object_data: 'hello world')
+        receiver.handle_message_for_object('object_one', msg)
+        msg2 = OpenStruct.new(object_data: 'goodbye world')
+        receiver.handle_message_for_object('object_two', msg2)
+
+        expect(handler_one_alpha.data).to eq(msg)
+        expect(handler_one_beta.data).to eq(msg)
+        expect(handler_two_alpha.data).to eq(msg2)
+      end
+    end
+  end
+
+  describe :loop_methods do
+    # These are very much "integration" tests as they test the main entry point
+    # and the conditions of the receiver from top to bottom.
+    describe :listen do
+      it 'registers, subscribes, calls methods, and DOES ALL THE THINGS' do
+        thread = Thread.new { receiver.listen }
+
+        get_receivers = -> { redis.smembers('data:object_one:receivers') }
+        expect(get_receivers).to eventually_equal(%w(bork))
+
+        redis.set('data:object_one:messages:1', fixture)
+        receivers = redis.smembers('data:object_one:receivers')
+        receivers.each do |receiver|
+          redis.rpush("data:object_one:#{receiver}:messages", '1')
+        end
+
+        message = Tincan::Message.from_json(fixture)
+        expect { handler_one_alpha.data }.to eventually_equal(message)
+        expect { handler_one_beta.data }.to eventually_equal(message)
+
+        thread.kill
+      end
+
+      xit 'calls a stored exception block on failure and keeps on ticking' do
+        pending 'Fails when part of an entire run, but not by itself.'
+        thread = Thread.new { receiver.listen }
+
+        get_receivers = -> { redis.smembers('data:object_one:receivers') }
+        expect(get_receivers).to eventually_equal(%w(bork))
+
+        bad_data = { name: 'this data sucks' }.to_json
+        redis.set('data:object_one:messages:2', bad_data)
+        receivers = redis.smembers('data:object_one:receivers')
+        receivers.each do |receiver|
+          redis.rpush("data:object_one:#{receiver}:messages", '2')
+        end
+
+        expect { exception_handler.data }.to eventually_be_a(NoMethodError)
+        expect { exception_handler.context }.to eventually_be_a(Hash)
+
+        thread.kill
+      end
+    end
+  end
+
+  describe :formatting_helper_methods do
+    describe :message_for_id do
+      let(:result) { receiver.message_for_id(1, 'bobsyouruncle') }
+      let(:message) { Tincan::Message.from_json(fixture) }
+      before do
+        redis.set('data:bobsyouruncle:messages:1', fixture)
+      end
+
+      it 'retrieves a message from Redis based on an ID and object' do
+        expect(result).to eq(message)
+      end
+
+      it 'is in the form of a Tincan::Message object' do
+        expect(result).to be_a(Tincan::Message)
+      end
+
+      it 'returns nil if the object was not found' do
+        redis.del('data:bobsyouruncle:messages:1')
+        expect(result).to be_nil
+      end
+    end
+
+    describe :message_list_keys do
+      it 'converts the listen_to ivar into properly-formatted Redis keys' do
+        expected = %w(one two).map do |i|
+          [
+            "data:object_#{i}:bork:messages",
+            "data:object_#{i}:bork:failures"
+          ]
+        end.flatten
+        expect(receiver.message_list_keys).to eq(expected)
+      end
+    end
+  end
+end

data/spec/sender_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Tincan::Sender do
+  let(:sender) { Tincan::Sender.new(options) }
+  let(:redis) { ::Redis.new(host: options[:redis_host]) }
+  let(:fixture) { IO.read('spec/fixtures/message.json').strip }
+  let(:message) { Tincan::Message.from_json(fixture) }
+  let(:options) do
+    {
+      redis_host: 'localhost',
+      redis_port: 6379,
+      namespace: 'data'
+    }
+  end
+
+  before { redis.flushdb }
+
+  describe :lifecycle do
+    it 'can be setup with a block' do
+      instance = Tincan::Sender.new do |config|
+        options.keys.each do |key|
+          config.send("#{key}=", options[key])
+        end
+      end
+
+      options.keys.each do |key|
+        expect(instance.send(key)).to eq(options[key])
+      end
+    end
+
+    it 'can be setup with an options hash' do
+      options.keys.each do |key|
+        expect(sender.send(key)).to eq(options[key])
+      end
+    end
+  end
+
+  describe :related_objects do
+    it 'memoizes a redis client' do
+      expect(sender.redis_client).to be_a(Redis)
+      expect(sender.redis_client.client.host).to eq(sender.redis_host)
+      expect(sender.redis_client.client.port).to eq(sender.redis_port)
+    end
+  end
+
+  describe :transactional_methods do
+    before { redis.sadd('data:object:receivers', 'some_client') }
+
+    describe :keys_for_receivers do
+      it 'grabs receivers from Redis, maps them into message list keys' do
+        result = sender.keys_for_receivers('object')
+        expect(result).to eq(%w(data:object:some_client:messages))
+      end
+    end
+
+    describe :flush_all_queues_for_object do
+      it 'deletes all receiver object keys using keys_for_receivers' do
+        redis.rpush('data:object:some_client:messages', 'message!!!')
+        expect(redis.llen('data:object:some_client:messages')).to eq(1)
+        sender.flush_all_queues_for_object('object')
+        expect(redis.llen('data:object:some_client:messages')).to eq(0)
+        result = redis.lpop('data:object:some_client:messages')
+        expect(result).to be_nil
+      end
+    end
+  end
+
+  describe :communication_methods do
+    # These are very much "integration" tests as they test the main entry point
+    # and the conditions of the sender from top to bottom.
+    describe :publish do
+      let(:dummy) do
+        instance = DummyClass.new
+        instance.name = 'Some Idiot'
+        instance
+      end
+
+      let(:message) do
+        Tincan::Message.new do |m|
+          m.object_name = 'dummy_class'
+          m.object_data = { name: dummy.name }
+          m.change_type = :create
+        end
+      end
+
+      before do
+        redis.sadd('data:dummy_class:receivers', 'some_client')
+        sender.publish(message)
+        @timestamp = Time.now.to_i
+      end
+
+      it 'publishes a message to Redis at a specific key' do
+        message = redis.get("data:dummy_class:messages:#{@timestamp}")
+        expect(message).to be_a(String)
+        expected = '{"object_name":"dummy_class","change_type":"create",'
+        expected += '"object_data":{"name":"Some Idiot"},"published_at":'
+        expect(message).to start_with(expected)
+      end
+
+      it 'also publishes a message ID to client-specific receiver lists' do
+        identifier = redis.lpop('data:dummy_class:some_client:messages')
+        expect(identifier).to eq(@timestamp.to_s)
+      end
+    end
+  end
+
+  describe :formatting_helper_methods do
+    describe :identifier_for_message do
+      it 'generates a timestamp from the passed-in message' do
+        expect(sender.identifier_for_message(message)).to eq(1401720216)
+      end
+    end
+
+    describe :primary_key_for_message do
+      it 'joins namespace, object name, and more to create a unique key' do
+        expected = 'data:dummy_class:messages:1401720216'
+        expect(sender.primary_key_for_message(message)).to eq(expected)
+      end
+    end
+  end
+end