philotic 0.8.1 → 1.0.1

data/lib/philotic/event.rb

@@ -1,100 +0,0 @@
-require 'philotic/constants'
-require 'philotic/routable'
-require 'philotic/singleton'
-
-module Philotic
-  class Event
-    include Philotic::Routable
-
-    attr_accessor :connection, :publish_error
-    attr_writer :published
-
-    def initialize(routables={}, payloads={}, connection=nil)
-      self.timestamp         = Time.now.to_i
-      self.philotic_firehose = true
-      self.connection = connection
-
-      # dynamically insert any passed in routables into both attr_routable
-      # and attr_payload
-      # result:  ability to arbitrarily send a easily routable hash
-      # over into the bus
-      _set_routables_or_payloads(:routable, routables)
-      _set_routables_or_payloads(:payload, payloads)
-
-      @published = false
-    end
-
-    def self.inherited(sub)
-      Philotic::PHILOTIC_HEADERS.each do |header|
-        sub.attr_routable header
-      end
-      self.attr_routable_readers.dup.each do |routable|
-        sub.attr_routable routable
-      end
-
-      self.attr_payload_readers.dup.each do |payload|
-        sub.attr_payload payload
-      end
-    end
-
-    self.inherited(self)
-
-    Philotic::MESSAGE_OPTIONS.each do |message_option|
-      attr_reader message_option
-      define_method :"#{message_option}=" do |val|
-        instance_variable_set(:"@#{message_option}", val)
-        self.message_metadata[message_option] = val
-      end
-    end
-
-    def connection
-      @connection ||= Philotic.connection
-    end
-
-    def published?
-     !!@published
-    end
-
-    def publish
-      connection.publish self
-    end
-
-    def self.publish(*args)
-      self.new(*args).publish
-    end
-
-    private
-
-    def _set_routables_or_payloads(type, attrs)
-      attrs.each do |key, value|
-        if self.respond_to?(:"#{key}=")
-          send(:"#{key}=", value)
-        elsif self.class == Philotic::Event
-          _set_event_attribute(type, key, value)
-        end
-      end
-    end
-
-    def _set_event_attribute(type, key, value)
-      _set_event_attribute_setter(key, type, value)
-      _set_event_attribute_getter(key, type)
-    end
-
-    def _set_event_attribute_getter(key, type)
-      self.class.send("attr_#{type}_readers").concat([key])
-      getter = lambda do
-        instance_variable_get(:"@#{key}")
-      end
-      self.class.send :define_method, :"#{key}", getter
-    end
-
-    def _set_event_attribute_setter(key, type, value)
-      self.class.send("attr_#{type}_writers").concat([:"#{key}="])
-      setter = lambda do |v|
-        instance_variable_set(:"@#{key}", v)
-      end
-      self.class.send :define_method, :"#{key}=", setter
-      self.send(:"#{key}=", value)
-    end
-  end
-end

data/lib/philotic/routable.rb

@@ -1,98 +0,0 @@
-require 'active_support/all'
-require 'active_record'
-
-module Philotic
-  module Routable
-    def self.included(base)
-      base.send :include, ActiveRecord::Validations
-      base.send :include, ActiveRecord::Callbacks
-      base.validates :philotic_firehose, :philotic_product, :philotic_component, :philotic_event_type, presence: true
-
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def attr_payload_reader *names
-        attr_payload_readers.concat(names)
-        attr_reader(*names)
-      end
-
-      def attr_payload_readers
-        @attr_payload_readers ||= []
-      end
-
-      def attr_payload_writer *names
-        attr_payload_writers.concat names
-        attr_writer(*names)
-      end
-
-      def attr_payload_writers
-        @attr_payload_writers ||= []
-      end
-
-      def attr_payload *names
-        names -= attr_payload_readers
-        attr_payload_readers.concat(names)
-        attr_payload_writers.concat(names)
-        attr_accessor(*names)
-      end
-
-      def attr_routable_reader *names
-        attr_routable_reader.concat(names)
-        attr_reader(*names)
-      end
-
-      def attr_routable_readers
-        @attr_routable_readers ||= []
-      end
-
-      def attr_routable_writers
-        @attr_routable_writers ||= []
-      end
-
-      def attr_routable_writer *names
-        attr_routable_writers.concat names
-        attr_writer(*names)
-      end
-
-      def attr_routable *names
-        names -= attr_routable_readers
-        attr_routable_readers.concat(names)
-        attr_routable_writers.concat(names)
-        attr_accessor(*names)
-      end
-    end
-
-    def payload
-      _payload_or_headers(:payload)
-    end
-
-    def headers
-      _payload_or_headers(:routable)
-    end
-
-    def attributes
-      payload.merge headers
-    end
-
-    def message_metadata
-      @message_metadata ||= {}
-    end
-
-    def message_metadata= options
-      @message_metadata ||= {}
-      @message_metadata.merge! options
-    end
-
-    private
-
-    def _payload_or_headers(payload_or_headers)
-      attribute_hash = {}
-      self.class.send("attr_#{payload_or_headers}_readers").each do |attr|
-        attr                 = attr.to_sym
-        attribute_hash[attr] = send(attr)
-      end
-      attribute_hash
-    end
-  end
-end

data/spec/philotic/event_spec.rb

@@ -1,109 +0,0 @@
-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 { expect(subject.class.methods).to include method_name.to_sym }
-  end
-
-  Philotic::MESSAGE_OPTIONS.each do |method_name|
-    specify { expect(subject.methods).to include method_name.to_sym }
-    specify { expect(subject.methods).to include "#{method_name}=".to_sym }
-  end
-
-  Philotic::PHILOTIC_HEADERS.each do |method_name|
-    specify { expect(subject.methods).to include method_name.to_sym }
-    specify { expect(subject.methods).to include "#{method_name}=".to_sym }
-  end
-
-  describe 'message_metadata' do
-    it 'should have a timestamp' do
-      Timecop.freeze
-      expect(subject.message_metadata).to eq(timestamp: Time.now.to_i)
-    end
-
-    it 'should reflect changes in the event properties' do
-      expect(subject.message_metadata[:app_id]).to eq nil
-      subject.app_id = 'ANSIBLE'
-      expect(subject.message_metadata[:app_id]).to eq 'ANSIBLE'
-    end
-  end
-  describe 'headers' do
-    it 'should include :philotic_product' do
-      expect(subject.headers.keys).to include :philotic_product
-    end
-  end
-
-  context 'generic event' do
-    let(:headers) do
-      {
-          header1: 'h1',
-          header2: 'h2',
-          header3: 'h3',
-      }
-    end
-
-    let(:payloads) do
-      {
-          payload1: 'h1',
-          payload2: 'h2',
-          payload3: 'h3',
-      }
-    end
-    it 'builds an event with dynamic headers and payloads' do
-      event = Philotic::Event.new(headers, payloads)
-
-      expect(event.headers).to include(headers)
-      expect(event.payload).to eq payloads
-
-    end
-  end
-
-  describe '#publish' do
-    subject { Philotic::Event.new }
-    specify do
-      expect(subject.connection).to receive(:publish).with(subject)
-
-      subject.publish
-    end
-
-  end
-
-  describe '.publish' do
-    let (:connection) { double }
-    let(:headers) do
-      {
-          header1: 'h1',
-          header2: 'h2',
-          header3: 'h3',
-      }
-    end
-
-    let(:payloads) do
-      {
-          payload1: 'h1',
-          payload2: 'h2',
-          payload3: 'h3',
-      }
-    end
-    subject { Philotic::Event }
-    specify do
-      expect_any_instance_of(Philotic::Event).to receive(:connection).and_return(connection)
-      expect(connection).to receive(:publish) do |event|
-        expect(event.headers).to include(headers)
-        expect(event.payload).to eq payloads
-      end
-
-      subject.publish(headers, payloads)
-    end
-
-  end
-end

data/spec/philotic/routable_spec.rb

@@ -1,54 +0,0 @@
-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 { expect(subject.methods).to 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
-        expect(subject.headers).to eq({routable_attr: nil})
-      end
-
-      it 'should have proper payload' do
-        expect(subject.payload).to eq({payload_attr: nil})
-      end
-
-      it 'should have proper attributes' do
-        expect(subject.attributes).to eq({routable_attr: nil, payload_attr:  nil})
-      end
-
-      it 'should have empty message_metadata' do
-        expect(subject.message_metadata).to eq({})
-      end
-
-      context 'overriding a value with message_metadata=' do
-        before do
-          routable_event_instance.message_metadata = {mandatory: false}
-        end
-        it 'should work' do
-          expect(subject.message_metadata).to eq(mandatory: false)
-        end
-      end
-    end
-  end
-end