fake_sns 0.0.1

data/lib/fake_sns/database.rb

@@ -0,0 +1,76 @@
+require "etc"
+require "aws-sdk"
+
+module FakeSNS
+  class Database
+
+    attr_reader :database_filename
+
+    def initialize(database_filename)
+      @database_filename = database_filename || File.join(Dir.home, ".fake_sns.yml")
+    end
+
+    def perform(action, params)
+      action_instance = action_provider(action).new(self, params)
+      action_instance.call
+      Response.new(action_instance)
+    end
+
+    def topics
+      @topics ||= TopicCollection.new(store)
+    end
+
+    def subscriptions
+      @subscriptions ||= SubscriptionCollection.new(store)
+    end
+
+    def messages
+      @messages ||= MessageCollection.new(store)
+    end
+
+    def reset
+      topics.reset
+      subscriptions.reset
+      messages.reset
+    end
+
+    def transaction
+      store.transaction do
+        yield
+      end
+    end
+
+    def replace(data)
+      store.replace(data)
+    end
+
+    def to_yaml
+      store.to_yaml
+    end
+
+    def each_deliverable_message
+      topics.each do |topic|
+        subscriptions.each do |subscription|
+          messages.each do |message|
+            if message.topic_arn == topic.arn
+              yield subscription, message
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def store
+      @store ||= Storage.for(database_filename)
+    end
+
+    def action_provider(action)
+      Actions.const_get(action)
+    rescue NameError
+      raise InvalidAction, "not implemented: #{action}"
+    end
+
+  end
+end

data/lib/fake_sns/deliver_message.rb

@@ -0,0 +1,100 @@
+require "forwardable"
+require "faraday"
+
+module FakeSNS
+  class DeliverMessage
+
+    extend Forwardable
+
+    def self.call(options)
+      new(options).call
+    end
+
+    attr_reader :subscription, :message, :config, :request
+
+    def_delegators :subscription, :protocol, :endpoint, :arn
+
+    def initialize(options)
+      @subscription = options.fetch(:subscription)
+      @message = options.fetch(:message)
+      @request = options.fetch(:request)
+      @config = options.fetch(:config)
+    end
+
+    def call
+      method_name = protocol.gsub("-", "_")
+      if protected_methods.map(&:to_s).include?(method_name)
+        send(method_name)
+      else
+        raise InvalidParameterValue, "Protocol #{protocol} not supported"
+      end
+    end
+
+    protected
+
+    def sqs
+      queue_name = endpoint.split(":").last
+      sqs = AWS::SQS.new(config["aws_config"] || {})
+      queue = sqs.queues.named(queue_name)
+      queue.send_message(message_contents)
+    end
+
+    def http
+      http_or_https
+    end
+
+    def https
+      http_or_https
+    end
+
+    def email
+      pending
+    end
+
+    def email_json
+      pending
+    end
+
+    def sms
+      pending
+    end
+
+    def application
+      pending
+    end
+
+    private
+
+    def message_contents
+      message.message_for_protocol protocol
+    end
+
+    def pending
+      puts "Not sending to subscription #{arn}, because protocol #{protocol} has no fake implementation. Message: #{message.id} - #{message_contents.inspect}"
+    end
+
+    def http_or_https
+      Faraday.new.post(endpoint) do |f|
+        f.body = {
+          "Type"             => "Notification",
+          "MessageId"        => message.id,
+          "TopicArn"         => message.topic_arn,
+          "Subject"          => message.subject,
+          "Message"          => message_contents,
+          "Timestamp"        => message.received_at.strftime("%Y-%m-%dT%H:%M:%SZ"),
+          "SignatureVersion" => "1",
+          "Signature"        => "Fake",
+          "SigningCertURL"   => "https://sns.us-east-1.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem",
+          "UnsubscribeURL"   => "", # TODO url to unsubscribe URL on this server
+        }.to_json
+        f.headers = {
+          "x-amz-sns-message-type"     => "Notification",
+          "x-amz-sns-message-id"       => message.id,
+          "x-amz-sns-topic-arn"        => message.topic_arn,
+          "x-amz-sns-subscription-arn" => arn,
+        }
+      end
+    end
+
+  end
+end

data/lib/fake_sns/error.rb

@@ -0,0 +1,34 @@
+module FakeSNS
+
+  class Error < StandardError
+  end
+
+  def self.error_type(status)
+    Class.new(Error) do
+      define_method :status do
+        status
+      end
+    end
+  end
+
+  # Common Errors, according to AWS docs
+  IncompleteSignature         = error_type 400
+  InternalFailure             = error_type 500
+  InvalidAction               = error_type 400
+  InvalidClientTokenId        = error_type 403
+  InvalidParameterCombination = error_type 400
+  InvalidParameterValue       = error_type 400
+  InvalidQueryParameter       = error_type 400
+  MalformedQueryString        = error_type 400
+  MissingAction               = error_type 400
+  MissingAuthenticationToken  = error_type 403
+  MissingParameter            = error_type 400
+  OptInRequired               = error_type 403
+  RequestExpired              = error_type 400
+  ServiceUnavailable          = error_type 403
+  Throttling                  = error_type 400
+
+  # Other errors
+  NotFound = error_type 404
+
+end

data/lib/fake_sns/error_response.rb

@@ -0,0 +1,46 @@
+module FakeSNS
+  class ErrorResponse
+
+    DEFAULT_CODE   = "InternalFailure"
+    DEFAULT_STATUS = 500
+
+    attr_reader :error, :parameters
+
+    def initialize(error, parameters)
+      @error = error
+      @parameters = parameters
+    end
+
+    def status
+      if error.respond_to?(:status)
+        error.status
+      else
+        DEFAULT_STATUS
+      end
+    end
+
+    # TODO figure out what this value does
+    def type
+      "Sender"
+    end
+
+    def code
+      if error.respond_to?(:code)
+        error.code
+      elsif error.is_a?(FakeSNS::Error)
+        error.class.to_s.split("::").last
+      else
+        DEFAULT_CODE
+      end
+    end
+
+    def message
+      error.message
+    end
+
+    def request_id
+      @request_id ||= SecureRandom.uuid
+    end
+
+  end
+end

data/lib/fake_sns/message.rb

@@ -0,0 +1,28 @@
+require "json"
+
+module FakeSNS
+  class Message
+
+    include Virtus.model
+
+    json = Class.new(Virtus::Attribute) do
+      def coerce(value)
+        value.is_a?(::Hash) ? value : JSON.parse(value)
+      end
+    end
+
+    attribute :id, String
+    attribute :subject, String
+    attribute :endpoint, String
+    attribute :topic_arn, String
+    attribute :structure, String
+    attribute :target_arn, String
+    attribute :received_at, DateTime
+    attribute :message, json
+
+    def message_for_protocol(type)
+      message.fetch(type.to_s) { message.fetch("default") }
+    end
+
+  end
+end

data/lib/fake_sns/message_collection.rb

@@ -0,0 +1,40 @@
+module FakeSNS
+  class MessageCollection
+
+    include Enumerable
+
+    def initialize(store)
+      @store = store
+      @store["messages"] ||= []
+    end
+
+    def collection
+      @store["messages"]
+    end
+
+    def reset
+      @store["messages"] = []
+    end
+
+    def each(*args, &block)
+      collection.map { |item| Message.new(item) }.each(*args, &block)
+    end
+
+    def fetch(arn, &default)
+      default ||= -> { raise InvalidParameterValue, "Unknown message #{arn}" }
+      found = collection.find do |message|
+        message["arn"] == arn
+      end
+      found || default.call
+    end
+
+    def create(attributes)
+      collection << attributes
+    end
+
+    def delete(arn)
+      collection.delete(fetch(arn))
+    end
+
+  end
+end

data/lib/fake_sns/response.rb

@@ -0,0 +1,16 @@
+require "securerandom"
+require "delegate"
+
+module FakeSNS
+  class Response < SimpleDelegator
+
+    def request_id
+      @request_id ||= SecureRandom.uuid
+    end
+
+    def template
+      __getobj__.class.name.to_s.split("::").last.gsub(/[A-Z]/){|m| "_#{m[0].downcase}"}.sub(/_/, '')
+    end
+
+  end
+end

data/lib/fake_sns/server.rb

@@ -0,0 +1,76 @@
+require "fake_sns"
+require "sinatra/base"
+
+module FakeSNS
+  class Server < Sinatra::Base
+
+    before do
+      content_type :xml
+    end
+
+    def database
+      $database ||= FakeSNS::Database.new(settings.database)
+    end
+
+    def action
+      params.fetch("Action") { raise MissingAction }
+    end
+
+    get "/" do
+      database.transaction do
+        database.to_yaml
+      end
+    end
+
+    post "/" do
+      database.transaction do
+        begin
+          response = database.perform(action, params)
+          status 200
+          erb :"#{response.template}.xml", scope: response
+        rescue Exception => error
+          p error
+          puts(*error.backtrace)
+          error_response = ErrorResponse.new(error, params)
+          status error_response.status
+          erb :"error.xml", scope: error_response
+        end
+      end
+    end
+
+    delete "/" do
+      database.transaction do
+        database.reset
+        200
+      end
+    end
+
+    put "/" do
+      database.replace(request.body.read)
+      200
+    end
+
+    post "/drain" do
+      database.transaction do
+        config = JSON.parse(request.body.read)
+        database.each_deliverable_message do |subscription, message|
+          DeliverMessage.call(subscription: subscription, message: message, request: request, config: config)
+        end
+      end
+      200
+    end
+
+    post "/drain/:message_id" do |message_id|
+      config = JSON.parse(request.body.read)
+      database.transaction do
+        database.each_deliverable_message do |subscription, message|
+          if message.id == message_id
+            DeliverMessage.call(subscription: subscription, message: message, request: request, config: config)
+          end
+        end
+      end
+      200
+    end
+
+  end
+end

data/lib/fake_sns/show_output.rb

@@ -0,0 +1,20 @@
+require 'rack/request'
+
+module FakeSNS
+  class ShowOutput
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      puts request.params.to_yaml
+      result = @app.call(env)
+      puts
+      puts(*result.last)
+      result
+    end
+
+  end
+end

data/lib/fake_sns/storage.rb

@@ -0,0 +1,75 @@
+require "yaml/store"
+
+module FakeSNS
+
+  class Storage
+
+    def self.for(database_filename)
+      if database_filename == ":memory:"
+        MemoryStorage.new(database_filename)
+      else
+        FileStorage.new(database_filename)
+      end
+    end
+
+    def initialize(database_filename)
+      @database_filename = database_filename
+    end
+
+    def [](key)
+      storage[key]
+    end
+
+    def []=(key, value)
+      storage[key] = value
+    end
+
+  end
+
+  class MemoryStorage < Storage
+
+    def to_yaml
+      storage.to_yaml
+    end
+
+
+    def storage
+      @storage ||= {}
+    end
+
+    def transaction
+      yield
+    end
+
+    def replace(data)
+      @storage = YAML.load(data)
+    end
+
+  end
+
+  class FileStorage < Storage
+
+    def to_yaml
+      storage["x"]
+      storage.instance_variable_get(:@table).to_yaml
+    end
+
+    def storage
+      @storage ||= YAML::Store.new(@database_filename)
+    end
+
+    def transaction
+      storage.transaction do
+        yield
+      end
+    end
+
+    def replace(data)
+      File.open(@database_filename, "w:utf-8") do |f|
+        f.write(data)
+      end
+    end
+
+  end
+
+end

data/lib/fake_sns/subscription.rb

@@ -0,0 +1,17 @@
+module FakeSNS
+  class Subscription
+
+    include Virtus.model
+
+    attribute :arn, String
+    attribute :protocol, String
+    attribute :endpoint, String
+    attribute :topic_arn, String
+    attribute :owner, String
+
+    def sqs?
+      protocol == "sqs"
+    end
+
+  end
+end

data/lib/fake_sns/subscription_collection.rb

@@ -0,0 +1,34 @@
+module FakeSNS
+  class SubscriptionCollection
+
+    include Enumerable
+
+    attr_reader :collection
+
+    def initialize(store)
+      @store = store
+      @store["subscriptions"] ||= []
+    end
+
+    def collection
+      @store["subscriptions"]
+    end
+
+    def reset
+      @store["subscriptions"] = []
+    end
+
+    def each(*args, &block)
+      collection.map { |item| Subscription.new(item) }.each(*args, &block)
+    end
+
+    def create(attributes)
+      collection << attributes
+    end
+
+    def delete(arn)
+      collection.delete(fetch(arn))
+    end
+
+  end
+end

data/lib/fake_sns/test_integration.rb

@@ -0,0 +1,110 @@
+require "faraday"
+
+module FakeSNS
+  class TestIntegration
+
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def host
+      option :sns_endpoint
+    end
+
+    def port
+      option :sns_port
+    end
+
+    def start
+      start! unless up?
+      reset
+    end
+
+    def start!
+      @pid = Process.spawn(binfile, "-p", port.to_s, "--database", database, :out => out, :err => out)
+      wait_until_up
+    end
+
+    def stop
+      if @pid
+        Process.kill("INT", @pid)
+        Process.waitpid(@pid)
+        @pid = nil
+      else
+        $stderr.puts "FakeSNS is not running"
+      end
+    end
+
+    def reset
+      connection.delete("/")
+    end
+
+    def url
+      "http://#{host}:#{port}"
+    end
+
+    def up?
+      @pid && connection.get("/").success?
+    rescue Errno::ECONNREFUSED, Faraday::Error::ConnectionFailed
+      false
+    end
+
+    def data
+      YAML.load(connection.get("/").body)
+    end
+
+    def drain(message_id = nil, options = {})
+      path = message_id ? "/drain/#{message_id}" : "/drain"
+      default = { aws_config: AWS.config.send(:supplied) }
+      body = default.merge(options).to_json
+      result = connection.post(path, body)
+      if result.success?
+        true
+      else
+        raise "Unable to drain messages: #{result.body}"
+      end
+    end
+
+    def connection
+      @connection ||= Faraday.new(url)
+    end
+
+    private
+
+    def database
+      options.fetch(:database) { ":memory:" }
+    end
+
+    def option(key)
+      options.fetch(key) { AWS.config.public_send(key) }
+    end
+
+
+    def wait_until_up(deadline = Time.now + 2)
+      fail "FakeSNS didn't start in time" if Time.now > deadline
+      unless up?
+        sleep 0.1
+        wait_until_up(deadline)
+      end
+    end
+
+    def binfile
+      File.expand_path("../../../bin/fake_sns", __FILE__)
+    end
+
+    def out
+      if debug?
+        :out
+      else
+        "/dev/null"
+      end
+    end
+
+    def debug?
+      ENV["DEBUG"].to_s == "true"
+    end
+
+  end
+end

data/lib/fake_sns/topic.rb

@@ -0,0 +1,13 @@
+module FakeSNS
+  class Topic
+
+    include Virtus.model
+
+    attribute :arn, String
+    attribute :name, String
+    attribute :policy, String
+    attribute :display_name, String
+    attribute :delivery_policy, String
+
+  end
+end