hushed 0.0.1

data/lib/hushed/message.rb

@@ -0,0 +1,43 @@
+module Hushed
+  class Message
+
+    NAMESPACE = "http://schemas.quietlogistics.com/V2/EventMessage.xsd"
+
+    class MissingDocumentError < StandardError; end
+    class MissingClientError < StandardError; end
+
+    attr_reader :client, :document, :xml
+
+    def initialize(options = {})
+      @xml = Nokogiri::XML::Document.parse(options[:xml]) if options[:xml]
+      @client = options[:client]
+      @document = options[:document]
+    end
+
+    def to_xml
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.EventMessage(attributes)
+      end
+      builder.to_xml
+    end
+
+    def document_type
+      @document ? @document.type : @xml.css('EventMessage').first['DocumentType']
+    end
+
+    def document_name
+      @document ? @document.filename : @xml.css('EventMessage').first['DocumentName']
+    end
+
+    def attributes
+      raise(MissingClientError.new("client cannot be missing")) unless @client
+      raise(MissingDocumentError.new("document cannot be missing")) unless @document
+      {
+        ClientId: @client.client_id, BusinessUnit: @client.business_unit,
+        DocumentName: @document.filename, DocumentType: @document.type,
+        Warehouse: @document.warehouse, MessageDate: @document.date.utc,
+        MessageId: @document.message_id, xmlns: NAMESPACE
+      }
+    end
+  end
+end

data/lib/hushed/queue.rb

@@ -0,0 +1,26 @@
+module Hushed
+  class Queue
+    attr_reader :client
+    def initialize(client)
+      @client = client
+    end
+
+    def send(message)
+      queue = client.to_quiet_queue
+      queue.send_message(message.to_xml)
+    end
+
+    def receive
+      queue = client.from_quiet_queue
+      message = nil
+      queue.receive_message do |msg|
+        message = Message.new(xml: msg.body)
+      end
+      message || Message.new
+    end
+
+    def approximate_pending_messages
+      client.from_quiet_queue.approximate_number_of_messages
+    end
+  end
+end

data/lib/hushed/request.rb

@@ -0,0 +1,11 @@
+require 'hushed/documents/request/shipment_order'
+
+module Hushed
+  module Request
+    VALID_REQUEST_TYPES = %w(ShipmentOrder)
+
+    def self.valid_type?(type)
+      VALID_REQUEST_TYPES.include?(type)
+    end
+  end
+end

data/lib/hushed/response.rb

@@ -0,0 +1,11 @@
+require 'hushed/documents/response/shipment_order_result'
+
+module Hushed
+  module Response
+    VALID_RESPONSE_TYPES = %w(ShipmentOrderResult)
+
+    def self.valid_type?(type)
+      VALID_RESPONSE_TYPES.include?(type)
+    end
+  end
+end

data/lib/hushed/version.rb

@@ -0,0 +1,3 @@
+module Hushed
+  VERSION = "0.0.1"
+end

data/spec/fixtures/credentials.yml

@@ -0,0 +1,12 @@
+access_key_id: abracadabra
+secret_access_key: alakazam
+client_id: HUSHED
+business_unit: HUSHED
+warehouse: SPACE
+buckets:
+  to: hushed-to-quiet
+  from: hushed-from-quiet
+queues:
+  to: http://queue.amazonaws/1234567890/hushed_to_quiet
+  from: http://queue.amazonaws/1234567890/hushed_from_quiet
+  inventory: http://queue.amazonaws/1234567890/hushed_inventory

data/spec/fixtures/documents/responses/shipment_order_result.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<SOResult 
+  xmlns="http://schemas.quiettechnology.com/V2/SOResultDocument.xsd"
+  ClientID="HUSHED"
+  BusinessUnit="HUSHED"
+  CartonCount="1"
+  DateShipped="2009-09-01T00:00:00Z"
+  FreightCost="10.00"
+  OrderNumber="1234567890">
+  <Line Line="1" Quantity="1" />
+  <Line Line="2" Quantity="1" />
+  <Carton 
+    Carrier="USPS"
+    CartonId="S12345678901"
+    CartonNumber="1"
+    FreightCost="10.00"
+    ServiceLevel="FIRST"
+    TrackingId="40000000000"
+    Weight="0.66">
+    <Content Line="1"Quantity="1" />
+    <Content Line="2"Quantity="1" />
+  </Carton>
+</SOResult>

data/spec/fixtures/messages/purchase_order_message.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<EventMessage
+  xmlns="http://schemas.quietlogistics.com/V2/EventMessage.xsd"
+  ClientId="HUSHED"
+  BusinessUnit="HUSHED"
+  DocumentName="HUSHED_PurchaseOrder_1234_20100927_132505124.xml"
+  DocumentType="PurchaseOrder"
+  MessageId="EF1CE966-38A2-428b-BA67-EFF23AF22F57"
+  Warehouse="CORP1"
+  MessageDate="2009-09-01T12:00:00Z">
+</EventMessage>

data/spec/remote/blackboard_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'hushed'
+require 'hushed/blackboard'
+
+module Hushed
+  describe "BlackboardRemote" do
+    include Configuration
+    include Fixtures
+
+    before do
+      AWS.config(stub_requests: false)
+      @client = Client.new(load_configuration)
+      @blackboard = Blackboard.new(@client)
+      @document = DocumentDouble.new(
+        message_id: '1234567',
+        date: Time.new(2013, 04, 05, 12, 30, 15).utc,
+        filename: 'neat_beans.xml',
+        client: @client,
+        type: 'ShipmentOrderResult'
+      )
+    end
+
+    after do
+      buckets = [@client.to_quiet_bucket, @client.from_quiet_bucket]
+      buckets.each { |bucket| bucket.objects.delete_all }
+    end
+
+    it "should be able to write a document to an S3 bucket" do
+      message = @blackboard.post(@document)
+      file = message.document_name
+      bucket = @client.to_quiet_bucket
+      assert bucket.objects[file].exists?, "It appears that #{file} was not written to S3"
+    end
+
+    it "should be able to fetch a document from an S3 bucket when given a message" do
+      expected_contents = load_response('shipment_order_result').read()
+      @client.from_quiet_bucket.objects[@document.filename].write(expected_contents)
+      message = MessageDouble.new(document_name: @document.filename, document_type: @document.type)
+      document = @blackboard.fetch(message)
+      assert_equal expected_contents, document.io
+    end
+  end
+end

data/spec/remote/queue_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'openssl'
+require 'hushed'
+require 'hushed/message'
+
+module Hushed
+  describe "QueueRemote" do
+    include Configuration
+
+    before do
+      AWS.config(:stub_requests => false)
+      @client = Client.new(load_configuration)
+      @sqs_queues = [@client.to_quiet_queue, @client.from_quiet_queue]
+      @default_wait_time = @sqs_queues.map(&:wait_time_seconds).max
+      @sqs_queues.each { |queue| queue.wait_time_seconds = 1 }
+
+      @document = DocumentDouble.new(
+        :message_id => '1234567',
+        :date => Time.new(2013, 04, 05, 12, 30, 15).utc,
+        :filename => 'neat_beans.xml',
+        :client => @client,
+        :type => 'Thinger'
+      )
+
+      @message = Message.new(:client => @client, :document => @document)
+      @queue = Queue.new(@client)
+    end
+
+    after do
+      @sqs_queues.each do |queue|
+        flush(queue)
+      end
+      @sqs_queues.each { |queue| queue.wait_time_seconds = @default_wait_time }
+    end
+
+    it "should be able to push a message onto the queue" do
+      expected_md5 = OpenSSL::Digest::MD5.new.hexdigest(@message.to_xml)
+      sent_message = @queue.send(@message)
+      assert_equal 1, @client.to_quiet_queue.approximate_number_of_messages
+      assert_equal expected_md5, sent_message.md5
+    end
+
+    it "should be able to fetch a message from the queue" do
+      @client.from_quiet_queue.send_message(@message.to_xml)
+      message = @queue.receive
+      assert_equal @message.to_xml, message.xml.to_xml
+      assert_equal @message.document_type, message.document_type
+      assert_equal @message.document_name, message.document_name
+    end
+
+    private
+    def flush(queue)
+      pending_messages = queue.approximate_number_of_messages
+      while pending_messages > 0
+        queue.receive_message do |message|
+          message.delete
+          pending_messages -= 1
+        end
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,169 @@
+require 'minitest/autorun'
+require 'nokogiri'
+require 'yaml'
+require 'mocha/setup'
+require 'hushed'
+
+module Fixtures
+  def load_fixture(path)
+    File.open(path, 'rb')
+  end
+
+  def load_response(response_name)
+    load_fixture("spec/fixtures/documents/responses/#{response_name}.xml")
+  end
+
+  def load_message(message_name)
+    load_fixture("spec/fixtures/messages/#{message_name}.xml")
+  end
+end
+
+module Configuration
+  def load_configuration
+    test_credentials_file = ENV['HOME'] + '/.hushed/credentials.yml'
+    test_credentials_file = "spec/fixtures/credentials.yml" unless File.exists?(test_credentials_file)
+    YAML.load(File.open(test_credentials_file, 'rb'))
+  end
+end
+
+class LineItemDouble
+  DEFAULT_OPTIONS = {
+    :id => 123456,
+    :quantity => 1,
+    :unit_of_measure => 'EA',
+    :price => '12.95'
+  }
+
+  attr_reader :id, :quantity, :unit_of_measure, :price
+  def initialize(options = {})
+    @id = options[:id]
+    @quantity = options[:quantity]
+    @unit_of_measure = options[:unit_of_measure]
+    @price = options[:price]
+  end
+
+  def self.example(options = {})
+    self.new(DEFAULT_OPTIONS.merge(options))
+  end
+end
+
+class AddressDouble
+  DEFAULT_OPTIONS = {
+    :company => 'Shopify',
+    :name => 'John Smith',
+    :address1 => '123 Fake St',
+    :address2 => 'Unit 128',
+    :city => 'Ottawa',
+    :province_code => 'ON',
+    :country_code => 'CA',
+    :zip => 'K1N 5T5'
+  }
+
+  attr_reader :company, :name, :address1, :address2, :city, :province_code
+  attr_reader :country_code, :zip
+  def initialize(options = {})
+    @company = options[:company]
+    @name = options[:name]
+    @address1 = options[:address1]
+    @address2 = options[:address2]
+    @city = options[:city]
+    @province_code = options[:province_code]
+    @country_code = options[:country_code]
+    @zip = options[:zip]
+  end
+
+  def self.example(options = {})
+    self.new(DEFAULT_OPTIONS.merge(options))
+  end
+end
+
+class ShippingLineDouble
+  def initialize(options = {})
+    @options = options
+  end
+
+  def carrier
+    @options[:code].split('_').first
+  end
+
+  def service_level
+    @options[:code].split('_').last
+  end
+end
+
+class OrderDouble
+  DEFAULT_OPTIONS = {
+    :line_items => [LineItemDouble.example],
+    :shipping_address => AddressDouble.example,
+    :billing_address => AddressDouble.example,
+    :note => 'Happy Birthday',
+    :created_at => Time.new(2013, 04, 05, 12, 30, 00),
+    :id => 123456,
+    :shipping_lines => [ShippingLineDouble.new(code: "FEDEX_GROUND", price: "34.40", source: "fedex", title: "FedEx Ground")],
+    :email => 'john@smith.com',
+    :total_price => '123.45'
+  }
+
+  attr_reader :line_items, :shipping_address, :billing_address, :note, :email
+  attr_reader :total_price, :email, :id, :type, :created_at, :shipping_lines
+  def initialize(options = {})
+    @line_items = options[:line_items]
+    @shipping_address = options[:shipping_address]
+    @billing_address = options[:billing_address]
+    @note = options[:note]
+    @created_at = options[:created_at]
+    @id = options[:id]
+    @shipping_lines = options[:shipping_lines]
+    @email = options[:email]
+    @total_price = options[:total_price]
+  end
+
+  def self.example(options = {})
+    self.new(DEFAULT_OPTIONS.merge(options))
+  end
+
+  def type
+    @type || "SO"
+  end
+end
+
+class DocumentDouble
+  include Hushed::Documents::Document
+  attr_accessor :type, :message_id, :warehouse, :date, :client
+  attr_accessor :business_unit, :document_number, :io
+
+  def initialize(options = {})
+    options.each do |key, value|
+      self.public_send("#{key}=".to_sym, value)
+    end
+  end
+
+  def to_xml
+    builder = Nokogiri::XML::Builder.new do |xml|
+      xml.DocumentDouble 'Hello World'
+    end
+    builder.to_xml
+  end
+
+  def filename=(filename)
+    @filename = filename
+  end
+end
+
+class MessageDouble
+  attr_accessor :document_name, :document_type
+
+  def initialize(options = {})
+    @document_name = options[:document_name]
+    @document_type = options[:document_type]
+  end
+end
+
+class ClientDouble
+  attr_accessor :client_id, :business_unit
+
+  def initialize(options = {})
+    @client_id = options[:client_id]
+    @business_unit = options[:business_unit]
+  end
+end

data/spec/unit/blackboard_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'hushed/blackboard'
+
+module Hushed
+  module Documents
+    module Response
+      class ThingerResponse
+        attr_reader :contents
+        def initialize(contents)
+          @contents = contents
+        end
+      end
+    end
+
+    module Request
+      class ThingerRequest
+        attr_reader :contents
+        def initialize(contents)
+          @contents = contents
+        end
+      end
+    end
+  end
+end
+
+module Hushed
+  describe "Blackboard" do
+    before do
+      @bucket = mock()
+
+      @client = mock()
+      @client.stubs(:to_quiet_bucket).returns(@bucket)
+      @client.stubs(:from_quiet_bucket).returns(@bucket)
+
+      @io = StringIO.new
+
+      @document = mock()
+      @document.stubs(:to_xml).returns("actually doesn't matter")
+      @document.stubs(:filename).returns("abracadabra_1234_xyz.xml")
+
+      @message = mock()
+      @message.stubs(:document_type).returns('ShipmentOrderResult')
+      @message.stubs(:document_name).returns('abracadabra_4321_zyx.xml')
+
+      @blackboard = Blackboard.new(@client)
+    end
+
+    it "should be possible to post a document to the blackboard" do
+      @bucket.expects(:objects).returns({@document.filename => @io})
+      @blackboard.post(@document)
+      assert_io(@document.to_xml, @io)
+    end
+
+    it "should be possible to build a document for a response type" do
+      Response.expects(:valid_type?).returns(true)
+      response = @blackboard.build_document('ThingerResponse', 'thinger')
+      assert_equal 'thinger', response.contents[:io]
+    end
+
+    it "should be possible to build a document for a request type" do
+      Request.expects(:valid_type?).returns(true)
+      response = @blackboard.build_document('ThingerRequest', 'thinger')
+      assert_equal 'thinger', response.contents[:io]
+    end
+
+    it "should return nil if the type was not valid" do
+      assert_equal nil, @blackboard.build_document('ThingerRequest', 'thinger')
+    end
+
+    it "should be possible to fetch a document from the blackboard" do
+      @io.write('fancy noodles')
+      @io.rewind
+      @bucket.expects(:objects).returns({@message.document_name => @io})
+      Response.expects(:valid_type?).returns(true)
+      @message.stubs(:document_type).returns('ThingerResponse')
+      assert_equal 'fancy noodles', @blackboard.fetch(@message).contents[:io]
+    end
+
+    it "should be possible to remove a document from the blackboard" do
+      s3object = mock()
+      s3object.expects(:delete)
+      s3object.expects(:exists?).returns(true)
+
+      @bucket.expects(:objects).returns({@message.document_name => s3object})
+      assert_equal true, @blackboard.remove(@message)
+    end
+
+    it "should not raise an exception if the document for removal couldn't be found" do
+      s3object = mock()
+      s3object.expects(:delete).never
+      s3object.expects(:exists?).returns(false)
+
+      @bucket.expects(:objects).returns({@message.document_name => s3object})
+      assert_equal false, @blackboard.remove(@message)
+    end
+
+    def assert_io(expectation, io)
+      io.rewind
+      assert_equal expectation, io.read
+    end
+  end
+end