fare 0.1.0

data/lib/fare/subscriber_stack.rb

@@ -0,0 +1,39 @@
+module Fare
+  class SubscriberStack
+
+    attr_reader :configuration, :topics, :run, :stack
+
+    def initialize(configuration, topics, run)
+      @configuration = configuration
+      @topics = topics
+      @run = run
+      @stack = []
+    end
+
+    def to_app
+      @app ||= build_stack
+    end
+
+    def handles?(event)
+      topics.any? { |topic| topic.handles?(event) }
+    end
+
+    private
+
+    def build_stack
+      instance_eval(&configuration.always_run)
+      instance_eval(&run)
+      raise "Stack is empty" if stack.empty?
+      stack.reverse.inject(endpoint) { |a, u| u[a] }
+    end
+
+    def use(middleware, *args, &block)
+      stack << lambda { |app| middleware.new(app, *args, &block) }
+    end
+
+    def endpoint
+      lambda { |event| event }
+    end
+
+  end
+end

data/lib/fare/test_mode.rb

@@ -0,0 +1,204 @@
+module Fare
+  module TestMode
+
+    class MessageList
+
+      def initialize
+        @all_messages_published = {}
+      end
+
+      def queue_adapter
+        @queue_adapter ||= QueueAdapter.new
+      end
+
+      def topic_adapter
+        @topic_adapter ||= TopicAdapter.new(self)
+      end
+
+      def register_publish(message)
+        event = Event.deserialize(message)
+        @all_messages_published[[event.subject.to_s, event.action.to_s]] ||= event
+      end
+
+      def clear
+        @all_messages_published.clear
+      end
+
+      def get(subject, action)
+        @all_messages_published[[subject.to_s, action.to_s]]
+      end
+
+      def size
+        @all_messages_published.size
+      end
+
+      def list
+        @all_messages_published.values.map { |event|
+          "* #{event.subject}##{event.action}"
+        }.join("\n")
+      end
+
+      def given_event(event_or_queue_name, event = nil)
+        if event
+          queue_name = event_or_queue_name
+        else
+          event = event_or_queue_name
+          queue_name = app_name
+        end
+        serialized_event = Event.new(event).serialize
+        queue = fetch_queue(queue_name.to_s)
+        queue.publish(serialized_event)
+      end
+
+      def run(queue_name = app_name)
+        subscriber = Subscriber.new(Fare.configuration, name: queue_name)
+        Timeout.timeout(2) do
+          while message = produce_message(subscriber)
+            subscriber.consume(message)
+          end
+        end
+      end
+
+      private
+
+      def produce_message(subscriber)
+        q = []
+        subscriber.produce(q)
+        q.first
+      end
+
+      def fetch_queue(queue_name)
+        queue_adapter.fetch(environment, queue_name)
+      end
+
+      def app_name
+        Fare.configuration.app_name
+      end
+
+      def environment
+        nil
+      end
+
+    end
+
+    class QueueAdapter
+
+      def initialize
+        @queues = {}
+      end
+
+      def fetch(environment, queue_name)
+        @queues[queue_name] ||= FakeQueue.new(queue_name)
+      end
+
+      def fetch_by_arn(arn)
+        @queues.fetch(arn)
+      end
+
+      def queues
+        @queues.values
+      end
+
+      def clear
+        queues.each(&:clear)
+      end
+
+      class FakeQueue
+
+        attr_reader :arn, :messages
+
+        def initialize(name)
+          @arn = name
+          @messages = []
+        end
+
+        def policy=(val)
+        end
+
+        def url
+          "http://#{arn}.sqs"
+        end
+
+        def publish(message)
+          @messages << message
+        end
+
+        def receive_message(*)
+          return nil if @messages.size == 0
+          Item.new(self, @messages[0])
+        end
+
+        def delete
+          @messages.delete_at(0)
+        end
+
+        def clear
+          @messages = []
+        end
+
+        def size
+          @messages.size
+        end
+
+        Item = Struct.new(:queue, :body) do
+
+          def delete
+            queue.delete
+          end
+
+        end
+
+      end
+
+    end
+
+    class TopicAdapter
+
+      def initialize(message_list)
+        @message_list = message_list
+        @topics = {}
+      end
+
+      def create(topic_name)
+        @topics[topic_name] ||= Topic.new(topic_name, @message_list)
+      end
+
+      def fetch(arn)
+        @topics.fetch(arn)
+      end
+
+      class Topic
+
+        attr_reader :arn, :name
+
+        def initialize(name, message_list)
+          @name = name
+          @arn = name
+          @queues = []
+          @message_list = message_list
+        end
+
+        def subscribe(queue_arn)
+          @queues << queue_arn
+          Subscription.new
+        end
+
+        def owner
+          :owner
+        end
+
+        def publish(message)
+          @message_list.register_publish(message)
+          @queues.each do |arn|
+            Fare.queue_adapter.fetch_by_arn(arn).publish(message)
+          end
+        end
+
+        Subscription = Struct.new(:raw_message_delivery)
+
+      end
+
+    end
+
+  end
+end

data/lib/fare/topic.rb

@@ -0,0 +1,25 @@
+module Fare
+  class Topic
+
+    attr_reader :subject, :action, :version
+
+    def initialize(options)
+      @subject = options.fetch(:subject)
+      @action  = options.fetch(:action)
+      @version = options[:version]
+    end
+
+    def handles?(event)
+      subject.to_s == event.subject && action.to_s == event.action
+    end
+
+    def [](key)
+      public_send(key)
+    end
+
+    def fetch(key)
+      public_send(key)
+    end
+
+  end
+end

data/lib/fare/topic_adapter.rb

@@ -0,0 +1,13 @@
+module Fare
+  class TopicAdapter
+
+    def self.fetch(arn)
+      AWS::SNS.new.topics[arn]
+    end
+
+    def self.create(topic_name)
+      AWS::SNS.new.topics.create(topic_name)
+    end
+
+  end
+end

data/lib/fare/update_cli.rb

@@ -0,0 +1,41 @@
+module Fare
+  class UpdateCLI
+
+    attr_reader :argv
+
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def call
+      options = {
+        filename:     Fare.default_config_file,
+        environment:  (Fare.default_environment || "development"),
+        force:        false,
+      }
+      parser = OptionParser.new do |o|
+        o.banner = <<-BANNER.gsub(/^ +/, '')
+          Creates topics in SNS, queues in SNS and makes sure the right subscriptions are made.
+          Also, information is cached.
+
+          Usage: fare update [options]
+        BANNER
+        o.on "--filename FILENAME", "Location of the Fare configuration file (default: #{options[:filename]})" do |filename|
+          options[:filename] = filename
+        end
+        o.on_tail "-h", "--help", "Shows this help page" do
+          puts o
+          exit
+        end
+        o.on "-E", "--environment ENVIRONMENT", "Name of the environment (default: #{options[:environment]})" do |environment|
+          options[:environment] = environment
+        end
+        o.on "-f", "--force", "Do it even if the lockfile is up to date" do
+          options[:force] = true
+        end
+      end
+      parser.parse!
+      Fare.update(options)
+    end
+  end
+end

data/lib/fare/version.rb

@@ -0,0 +1,3 @@
+module Fare
+  VERSION = "0.1.0"
+end

data/spec/logger_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe "Fare::Middleware::Logging" do
+
+  let(:out) { StringIO.new }
+  let(:event) { Fare::Event.new(id: "abc", subject: "X", action: "Y") }
+
+  it "logs successful events" do
+    app = ->(env) { sleep 0.1 }
+    logging = logging_stack(app)
+
+    logging.call(event: event)
+
+    expect(logged.fetch("result")).to eq "success"
+    expect(logged.fetch("event").fetch("action")).to eq "Y"
+    expect(logged.fetch("event").fetch("subject")).to eq "X"
+  end
+
+  it "logs errors" do
+    error = RuntimeError.new("my error")
+    app = ->(env) { sleep 0.1; raise error }
+    logging = logging_stack(app)
+
+    expect { logging.call(event: event) }.to raise_error error
+
+    expect(logged.fetch("result")).to eq "failure"
+    expect(logged.fetch("event").fetch("action")).to eq "Y"
+    expect(logged.fetch("event").fetch("subject")).to eq "X"
+    expect(logged.fetch("error_class")).to eq "RuntimeError"
+    expect(logged.fetch("error_message")).to eq "my error"
+    expect(logged.fetch("backtrace")).to eq error.backtrace
+  end
+
+  def logged
+    @logged ||= begin
+                  out.rewind
+                  logged = out.read
+                  _, json = logged.split(/Handled event:/, 2)
+                  JSON.parse(json.strip)
+                end
+  end
+
+  def logging_stack(app)
+    Fare::Middleware::Logging.new(app, logger: Logger.new(out))
+  end
+
+end

data/spec/raven_spec.rb

@@ -0,0 +1,52 @@
+class Raven
+
+  attr_accessor :dsn, :logger, :environments, :excluded_exceptions, :options, :exception
+
+  def self.raven
+    @raven ||= new
+  end
+
+  def self.configure
+    yield raven
+  end
+
+  def self.capture_exception(exception, options = {})
+    raven.exception = exception
+  end
+
+  def self.extra_context(options)
+    raven.options = { extra: options }
+  end
+
+  class Context
+    def self.clear!
+    end
+  end
+
+end
+
+RSpec.describe "Fare::Middleware::Raven" do
+
+  it "configures Raven and logs errors" do
+    error = RuntimeError.new("my error")
+    app = ->(env) { sleep 0.1; raise error }
+    raven = Fare::Middleware::Raven.new(app, dsn: "http://localhost:5154", environment: "test", logger: "logger")
+    event = Fare::Event.new(id: "abc", subject: "X", action: "Y")
+
+    expect(Raven.raven.dsn).to eq "http://localhost:5154"
+    expect(Raven.raven.logger).to eq "logger"
+    expect(Raven.raven.environments).to eq ["test"]
+    expect(Raven.raven.excluded_exceptions).to eq []
+
+    expect { raven.call(event: event, foo: "bar") }.to raise_error error
+
+    expect(Raven.raven.exception).to eq error
+    expect(Raven.raven.options).to eq(
+      extra: {
+        "event" => Hash[event.attributes.map { |k,v| [ k.to_s, v ] }],
+        "foo" => "bar",
+      },
+    )
+  end
+
+end

data/spec/rspec_integration_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe "RSpec integration" do
+
+  before do
+    write_fare_config <<-CONFIG
+      publishes subject: "user", action: "login"
+      publishes subject: "user", action: "signup"
+    CONFIG
+    Fare.test_mode!
+  end
+
+  it "expects based on subject and action" do
+    expect {
+      Fare.publish(subject: "user", action: "login", payload: "payload")
+    }.to publish :user, :login
+  end
+
+  it "fails when nothing is published" do
+    expect {
+      expect { }.to publish :user, :login
+    }.to raise_error RSpec::Expectations::ExpectationNotMetError, "There were no events published"
+  end
+
+  it "fails when the wrong event was published" do
+    expect {
+      expect {
+        Fare.publish(subject: "user", action: "signup", payload: "payload")
+      }.to publish :user, :login
+    }.to raise_error RSpec::Expectations::ExpectationNotMetError, "Expected event user#login, but got:\n* user#signup"
+  end
+
+  it "matches the payload with the help of JsonExpressions" do
+    expect {
+      Fare.publish(subject: "user", action: "login", payload: { user_id: 123 })
+    }.to publish :user, :login, user_id: Fixnum
+  end
+
+  it "fails when payload doesn't match" do
+    expect {
+      expect {
+        Fare.publish(subject: "user", action: "login", payload: { user_id: "abc" })
+      }.to publish :user, :login, user_id: Fixnum
+    }.to raise_error RSpec::Expectations::ExpectationNotMetError, /Payload did not match/
+  end
+
+end