philotic 0.0.1

data/lib/philotic/tasks.rb

@@ -0,0 +1 @@
+require 'philotic/tasks/init_queues'

data/lib/philotic/tasks/init_queues.rb

@@ -0,0 +1,28 @@
+desc "initialize named durable queues"
+namespace :philotic do
+  task :init_queues, :filename do |t, args|
+    raise "You must specify a file name for #{t.name}: rake #{t.name}[FILENAME] #yes, you need the brackets, no space." if !args[:filename]
+
+    # ENV['INITIALIZE_NAMED_QUEUE'] must equal 'true' to run Philotic.initialize_named_queue!
+    ENV['INITIALIZE_NAMED_QUEUE'] = 'true'
+
+    require 'philotic'
+
+    @filename = args[:filename]
+    queues = YAML.load_file(@filename)
+
+    EM.run do
+      def init_queues queues, index = 0
+        Philotic.initialize_named_queue!("#{queues.keys.sort[index]}", queues[queues.keys.sort[index]]) do |q|
+          if index == queues.size - 1
+            Philotic::Connection.close { EM.stop }
+          else
+            init_queues queues, index + 1
+          end
+        end
+      end
+
+      init_queues queues
+    end
+  end
+end

data/lib/philotic/version.rb

@@ -0,0 +1,3 @@
+module Philotic
+  VERSION = '0.0.1'
+end

data/philotic.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/philotic/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Nathan Keyes']
+  gem.email         = ['nkeyes@gmail.com']
+  gem.description   = %q{Lightweight, opinionated wrapper for using RabbitMQ headers exchanges}
+  gem.summary       = %q{Lightweight, opinionated wrapper for using RabbitMQ headers exchanges}
+  gem.homepage      = 'https://github.com/nkeyes/philotic'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = 'philotic'
+  gem.require_paths = ['lib']
+  gem.version       = Philotic::VERSION
+  gem.licenses       = ['MIT']
+
+  gem.add_dependency 'activesupport', '~> 4.0'
+  gem.add_dependency 'activerecord', '~> 4.0'
+  gem.add_dependency 'amqp', '~> 1.2'
+  gem.add_dependency 'awesome_print', '~> 1.2'
+  gem.add_dependency 'json', '~> 1.8'
+end

data/philotic.yml.example

@@ -0,0 +1,36 @@
+defaults: &defaults
+  #connection settings
+  rabbit_host: localhost
+  # connection_failed_handler: method/proc
+  # connection_loss_handler: method/proc
+  timeout: 2
+  
+  #exchange settings
+  exchange_name: philotic.headers
+  # message_return_handler: method/proc
+  
+  #message settings
+  routing_key: ~
+  persistent: true
+  # immediate: true
+  mandatory: true
+  content_type: ~
+  content_encoding: ~
+  priority: ~
+  message_id: ~
+  correlation_id: ~
+  reply_to: ~
+  type: ~
+  user_id: ~
+  app_id: MY_APP
+  timestamp: ~
+  expiration: ~
+  
+development:
+  <<: *defaults
+
+test:
+  <<: *defaults
+
+production:
+  <<: *defaults

data/philotic_queues.yml.example

@@ -0,0 +1,19 @@
+available_or_male:
+  gender: Male
+  available: true
+  x-match: any
+  
+available_male:
+  gender: Male
+  available: true
+  x-match: all
+  
+available_or_female:
+  gender: Female
+  available: true
+  x-match: any
+  
+available_female:
+  gender: Female
+  available: true
+  x-match: all

data/spec/connection_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Philotic::Connection do
+  let(:connection){ Philotic::Connection }
+  subject { connection } 
+  
+  describe "config" do
+    it "should return the Philotic::Config singleton" do
+      subject.config.should == Philotic::Config
+    end
+  end
+  
+  describe "exchange" do
+    #TODO make sure rabbit is running for CI to run this
+    xit "should return an instance of AMQP::Exchange" do
+      subject.exchange.should be_a AMQP::Exchange
+    end
+  end
+end

data/spec/event_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+# create 'deep' inheritance to test self.inherited
+class TestEventParent < Philotic::Event
+end
+class TestEvent < TestEventParent
+end
+
+describe Philotic::Event do
+  let(:event){ TestEvent.new }
+  subject { event }
+  
+  Philotic::Routable::ClassMethods.instance_methods.sort.each do |method_name|
+    specify { subject.class.methods.should include method_name.to_sym }
+  end
+  
+  Philotic::MESSAGE_OPTIONS.each do |method_name|
+    specify { subject.methods.should include method_name.to_sym }
+    specify { subject.methods.should include "#{method_name}=".to_sym }
+  end
+  
+  Philotic::PHILOTIC_HEADERS.each do |method_name|
+    specify { subject.methods.should include method_name.to_sym }
+    specify { subject.methods.should include "#{method_name}=".to_sym }
+  end
+  
+  describe "message_metadata" do
+    it "should have a timestamp" do
+      Timecop.freeze
+      subject.message_metadata.should == {timestamp: Time.now.to_i}
+    end
+    
+    it "should reflect changes in the event properties" do
+      subject.message_metadata[:app_id]. should == nil
+      subject.app_id = 'ANSIBLE'
+      subject.message_metadata[:app_id]. should == 'ANSIBLE'
+    end
+  end
+  describe "headers" do
+    it "should include :philotic_product" do
+      subject.headers.keys.should include :philotic_product
+    end
+  end
+end

data/spec/publisher_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'philotic/dummy_event'
+
+describe Philotic::Publisher do
+  before(:each) do
+    @event = Philotic::DummyEvent.new
+    @event.subject = "Hello"
+    @event.message = "How are you?"
+    @event.gender = :M
+    @event.available = true
+  end
+  let(:publisher) { Philotic::Publisher }
+  subject { publisher }
+
+  describe "config" do
+    it "should return the Philotic::Config singleton" do
+      subject.config.should == Philotic::Config
+    end
+  end
+
+  describe "exchange" do
+    #TODO make sure rabbit is running for CI to run this
+    xit "should return an instance of AMQP::Exchange" do
+      subject.exchange.should be_a AMQP::Exchange
+    end
+  end
+
+  describe "publish" do
+    it "should call raw_publish with the right values" do
+      Timecop.freeze
+      subject.should_receive(:raw_publish).with(
+          {
+              subject: 'Hello',
+              message: "How are you?"
+          },
+          {
+              headers: {
+                  philotic_firehose: true,
+                  philotic_product: nil,
+                  philotic_component: nil,
+                  philotic_event_type: nil,
+                  gender: :M,
+                  available: true
+              },
+              timestamp: Time.now.to_i
+          }
+      )
+      subject.publish(@event)
+    end
+
+  end
+
+  describe "raw_publish" do
+
+    xit "should call exchange.publish with the right values" do
+      Timecop.freeze
+      Philotic::Connection.instance.should_receive(:connected?).and_return { true }
+
+      AMQP::Exchange.any_instance.should_receive(:publish).with(
+          {
+              subject: 'Hello',
+              message: "How are you?"
+          }.to_json,
+          {
+              routing_key: nil,
+              persistent: true,
+              mandatory: true,
+              content_type: nil,
+              content_encoding: nil,
+              priority: nil,
+              message_id: nil,
+              correlation_id: nil,
+              reply_to: nil,
+              type: nil,
+              user_id: nil,
+              app_id: nil,
+              expiration: nil,
+              headers: {
+                  philotic_firehose: true,
+                  philotic_product: nil,
+                  philotic_component: nil,
+                  philotic_event_type: nil,
+                  gender: :M,
+                  available: true
+              },
+              timestamp: Time.now.to_i
+          }
+      )
+      subject.publish(@event)
+    end
+
+    xit "should log an error when there is no connection" do
+
+      4.times do
+        Philotic::Connection.instance.should_receive(:connected?).and_return { false }
+      end
+      Philotic.logger.should_receive(:error)
+      subject.publish(@event)
+    end
+
+  end
+end

data/spec/routable_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Philotic::Routable do
+  context "including the module on class" do
+    let(:routable_event_class){
+      Class.new do
+        include Philotic::Routable
+        attr_routable :routable_attr
+        attr_payload :payload_attr
+      end
+    }
+    subject { routable_event_class}
+
+    %w{ attr_payload_reader attr_payload_readers 
+        attr_payload_writer attr_payload_writers 
+        attr_payload 
+        
+        attr_routable_reader attr_routable_readers 
+        attr_routable_writers attr_routable_writer 
+        attr_routable }.each do |method_name|
+      specify { subject.methods.should include method_name.to_sym }
+    end
+
+    context " and then instantiating it" do
+      let(:routable_event_instance){ routable_event_class.new }
+      subject { routable_event_instance }
+
+      it 'should have proper headers' do
+        subject.headers.should == { routable_attr: nil }
+      end
+
+      it 'should have proper payload' do
+        subject.payload.should == { payload_attr: nil }
+      end
+
+      it 'should have proper attributes' do
+        subject.attributes.should == { routable_attr: nil,
+                                       payload_attr: nil }
+      end
+
+      it 'should call Philotic::Publisher.publish with subject' do
+        Philotic::Publisher.should_receive(:publish).with(subject)
+        subject.publish
+      end 
+
+      it 'should have empty message_metadata' do
+        subject.message_metadata.should == {}
+      end
+
+      context " overriding a value with message_metadata=" do
+        before do
+          routable_event_instance.message_metadata = { mandatory: false }
+        end
+        its(:message_metadata) { should eq( mandatory: false ) }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'support'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'config'))
+
+
+require 'rubygems'
+require 'bundler/setup'
+require 'philotic'
+
+Bundler.require(:default, :test)
+
+RSpec.configure do |config|
+  #Run any specs tagged with focus: true or all specs if none tagged
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+
+  config.after do
+    Timecop.return
+  end
+  
+end
+#Philotic.logger = Logger.new("/dev/null")

data/spec/subscriber_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'philotic/dummy_event'
+
+describe Philotic::Subscriber do
+  let(:subscriber) do
+    subscriber = Philotic::Subscriber.new(arguments: {'x-match' => 'any', philotic_firehose: true}) do |metadata, payload|
+      true
+    end
+    subscriber
+  end
+
+  describe "subscribe" do
+    xit "should call AMQP.channel.queue with the right values" do
+      queue = double(AMQP::Queue)
+      queue.stub(:bind) { queue }
+      queue.stub(:subscribe) { queue }
+      channel = double(AMQP::Channel)
+      exchange = double(AMQP::Exchange)
+      channel.stub(:queue) { queue }
+      channel.stub(:headers) { exchange }
+      AMQP.stub(:channel) { channel }
+
+      channel.should_receive(:queue).with("", {auto_delete: true, durable: false})
+      queue.should_receive(:bind).with(exchange, {arguments: {"x-match" => "any", philotic_firehose: true}})
+      queue.should_receive(:subscribe).with({})
+      Philotic::Subscriber.subscribe(arguments: {'x-match' => 'any', philotic_firehose: true}) do |metadata, payload|
+        true
+      end
+    end
+  end
+
+  describe "subscribe_to_any_of" do
+    xit "should call AMQP.channel.queue with the right values" do
+      queue = double(AMQP::Queue)
+      queue.stub(:bind) { queue }
+      queue.stub(:subscribe) { queue }
+      channel = double(AMQP::Channel)
+      exchange = double(AMQP::Exchange)
+      channel.stub(:queue) { queue }
+      channel.stub(:headers) { exchange }
+      AMQP.stub(:channel) { channel }
+
+      channel.should_receive(:queue).with("", {auto_delete: true, durable: false})
+      queue.should_receive(:bind).with(exchange, {arguments: {"x-match" => "any", philotic_firehose: true}})
+      queue.should_receive(:subscribe).with({})
+      Philotic::Subscriber.subscribe_to_any_of(arguments: {philotic_firehose: true}) do |metadata, payload|
+        true
+      end
+    end
+  end
+
+  describe "subscribe_to_all_of" do
+    xit "should call AMQP.channel.queue with the right values" do
+      queue = double(AMQP::Queue)
+      queue.stub(:bind) { queue }
+      queue.stub(:subscribe) { queue }
+      channel = double(AMQP::Channel)
+      exchange = double(AMQP::Exchange)
+      channel.stub(:queue) { queue }
+      channel.stub(:headers) { exchange }
+      AMQP.stub(:channel) { channel }
+
+      channel.should_receive(:queue).with("", {auto_delete: true, durable: false})
+      queue.should_receive(:bind).with(exchange, {arguments: {"x-match" => "all", philotic_firehose: true}})
+      queue.should_receive(:subscribe).with({})
+      Philotic::Subscriber.subscribe_to_all_of(arguments: {philotic_firehose: true}) do |metadata, payload|
+        true
+      end
+    end
+  end
+
+end