gentle 0.1.0

data/spec/unit/blackboard_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'gentle/blackboard'
+
+module Gentle
+  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 Gentle
+  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

data/spec/unit/client_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'gentle/client'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/keys'
+
+module Gentle
+  describe "Client" do
+    before do
+      AWS.config(:stub_requests => true)
+      @options = {
+        access_key_id: 'abracadabra',
+        secret_access_key: 'alakazam',
+        client_id: 'Gentle',
+        business_unit: 'Gentle',
+        warehouse: 'SPACE',
+        buckets: {
+          to: 'gentle-to-quiet',
+          from: 'gentle-from-quiet'
+        },
+        queues: {
+          to: 'http://queue.amazonaws.com/123456789/gentle_to_quiet',
+          from: 'http://queue.amazonaws.com/123456789/gentle_from_quiet',
+          inventory: 'http://queue.amazonaws.com/123456789/gentle_inventory'
+        }
+      }
+      @client = Client.new(@options)
+    end
+
+    after do
+      AWS.config(:stub_requests => false)
+    end
+
+    it "should be able to handle configuration that is passed in with keys as strings" do
+      client = Client.new(@options.stringify_keys)
+      assert_equal 'Gentle', client.client_id
+      assert_equal 'Gentle', client.business_unit
+    end
+
+    it "should not be possible to initialize a client without credentials" do
+      assert_raises Client::InitializationError do
+        Client.new(@options.except(:access_key_id, :secret_access_key))
+      end
+    end
+
+    it "should not be possible to initialize a client without a client_id" do
+      assert_raises Client::InitializationError do
+        Client.new(@options.except(:client_id))
+      end
+    end
+
+    it "should not be possible to initialize a client with a business_unit" do
+      assert_raises Client::InitializationError do
+        Client.new(@options.except(:business_unit))
+      end
+    end
+
+    it "should not be possible to initialize a client with missing bucket information" do
+      assert_raises Client::InitializationError do
+        Client.new(@options.except(:buckets))
+      end
+    end
+
+    it "should not be possible to initialize a client with partial bucket information" do
+      assert_raises Client::InitializationError do
+        buckets = {to: 'neato'}
+        Client.new(@options.merge(buckets: buckets))
+      end
+    end
+
+    it "should not be possible to initialize a client with missing queue information" do
+      assert_raises Client::InitializationError do
+        Client.new(@options.except(:queues))
+      end
+    end
+
+    it "should not be possible to initialize a client with partial queue information" do
+      assert_raises Client::InitializationError do
+        queues = {inventory: 'neato'}
+        Client.new(@options.merge(queues: queues))
+      end
+    end
+
+    it "should raise an error if the bucket names are invalid" do
+      AWS::S3::Bucket.any_instance.expects(:exists?).returns(false)
+      assert_raises Client::InvalidBucketError do
+        @client.to_quiet_bucket
+      end
+    end
+
+    it "should raise an error if the queue names are invalid" do
+      AWS::SQS::Queue.any_instance.expects(:exists?).returns(false)
+      assert_raises Client::InvalidQueueError do
+        @client.to_quiet_queue
+      end
+    end
+  end
+end

data/spec/unit/documents/document_spec.rb

@@ -0,0 +1,44 @@
+module Gentle
+  module Documents
+    module DocumentInterfaceTestcases
+
+      def test_it_should_be_able_to_generate_a_filename
+        assert bn = @object.business_unit
+        assert type = @object.type
+        assert number = @object.document_number
+        assert date = @object.date.strftime("%Y%m%d_%H%M%S")
+        expected_filename = "#{bn}_#{type}_#{number}_#{date}.xml"
+        assert_equal expected_filename, @object.filename
+      end
+
+      def test_it_should_respond_to_warehouse
+        assert @object.respond_to?(:warehouse), "#{@object.class} does not respond to #warehouse"
+      end
+
+      def test_it_should_be_initializable_with_a_hash
+        begin
+          @object.class.new(:thinger => 123)
+        rescue TypeError
+          flunk "It should be possible to initialize #{@object.class} with an args hash"
+        rescue StandardError
+        end
+      end
+
+    end
+  end
+
+  describe "DocumentDouble" do
+    include Documents::DocumentInterfaceTestcases
+
+    before do
+      @object = DocumentDouble.new(
+        :message_id => '1234567',
+        :date => Time.new(2013, 04, 05, 12, 30, 15).utc,
+        :client => @client,
+        :type => 'Thinger',
+        :business_unit => 'Gentle',
+        :document_number => '123456'
+      )
+    end
+  end
+end

data/spec/unit/documents/request/hash_converter_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'gentle/documents/request/shipment_order'
+require 'gentle/documents/request/hash_converter'
+
+module Gentle
+  module Documents
+    module Request
+      describe "ShipmentOrder" do
+        include Gentle::Documents::Request::HashConverter
+
+        it "serializes the line item parts into a hash" do
+          part = PartLineItemDouble.example(
+            variant: VariantDouble.example(id: 1214, sku: "SKU42", price: 25.95),
+            line_item: LineItemDouble.example(quantity: 3)
+          )
+
+          hash = part_line_item_hash(part)
+
+          assert_equal "SKU42", hash['ItemNumber']
+          assert_instance_of Fixnum, hash['Line']
+          assert_equal 3, hash['QuantityOrdered']
+          assert_equal 3, hash['QuantityToShip']
+          assert_equal "EA", hash['UOM']
+          assert_equal 25.95, hash['Price']
+        end
+
+        it "serializes the line item into a hash" do
+          item = LineItemDouble.example
+
+          hash = line_item_hash(item)
+
+          assert_equal item.sku, hash['ItemNumber']
+          assert_instance_of Fixnum, hash['Line']
+          assert_equal item.quantity, hash['QuantityOrdered']
+          assert_equal item.quantity, hash['QuantityToShip']
+          assert_equal "EA", hash['UOM']
+          assert_equal item.price, hash['Price']
+        end
+      end
+    end
+  end
+end

data/spec/unit/documents/request/shipment_order_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+require 'gentle/documents/request/shipment_order'
+
+module Gentle
+  module Documents
+    module Request
+      describe "ShipmentOrder" do
+        include Gentle::Documents::DocumentInterfaceTestcases
+
+        before do
+          @shipment = ShipmentDouble.example
+          @order = @shipment.order
+          @client = ClientDouble.new(:client_id => 'Gentle', :business_unit => 'Gentle', :warehouse => 'SPACE')
+          @object = @shipment_order = ShipmentOrder.new(shipment: @shipment, client: @client)
+        end
+
+        it "should raise an error if an shipment wasn't passed in" do
+          assert_raises KeyError do
+            ShipmentOrder.new(client: @client)
+          end
+        end
+
+        it "should be able to generate an XML document" do
+          message = ShipmentOrder.new(:shipment => @shipment, :client => @client)
+          document = Nokogiri::XML::Document.parse(message.to_xml)
+
+          expected_namespaces = {'xmlns' => ShipmentOrder::NAMESPACE}
+          assert_equal expected_namespaces, document.collect_namespaces()
+
+          assert_equal 1, document.css('ShipOrderDocument').length
+
+          assert_equal @client.client_id, document.css('ClientID').first.text
+          assert_equal @client.business_unit, document.css('BusinessUnit').first.text
+
+          assert_header(document.css('OrderHeader').first)
+          assert_equal @order.note, document.css('Comments').first.text
+
+          assert_shipping(document.css('ShipMode').first)
+
+          assert_address(@order.email, @order.shipping_address, document.css('ShipTo').first)
+          assert_address(@order.email, @order.billing_address, document.css('BillTo').first)
+
+          order_details = document.css('OrderDetails')
+          assert_equal 1, order_details.length
+          assert_line_item(@order.line_items.first, order_details.first)
+        end
+
+        it "uses a sequence as the Line attribute of the OrderDetails" do
+          order = OrderDouble.example(line_items: [
+                    LineItemDouble.example(sku: "SKU-1"),
+                    LineItemDouble.example(sku: "SKU-2"),
+                    LineItemDouble.example(sku: "SKU-3")
+                  ])
+          shipment = ShipmentDouble.example(order: order)
+
+          message = ShipmentOrder.new(:shipment => shipment, :client => @client)
+
+          document = Nokogiri::XML::Document.parse(message.to_xml)
+          order_details = document.css('OrderDetails')
+          assert_equal "1", order_details[0]['Line']
+          assert_equal "2", order_details[1]['Line']
+          assert_equal "3", order_details[2]['Line']
+        end
+
+        it "explodes phase 1 items into individual skus" do
+          phase_1_set = LineItemDouble.example(sku: "GPS1-5")
+          order = OrderDouble.example(line_items: [
+                    phase_1_set,
+                    LineItemDouble.example
+                  ])
+          shipment = ShipmentDouble.example(order: order)
+
+          message = ShipmentOrder.new(:shipment => shipment, :client => @client)
+
+          document = Nokogiri::XML::Document.parse(message.to_xml)
+          order_details = document.css('OrderDetails')
+          assert_equal 5, order_details.count
+          assert_equal "GMJC100", order_details[0]['ItemNumber']
+          assert_equal "GPM100", order_details[1]['ItemNumber']
+          assert_equal "GBD100-3", order_details[2]['ItemNumber']
+          assert_equal "GPST100 - 2", order_details[3]['ItemNumber']
+        end
+
+        it "explodes the line items into parts when applicable" do
+          line_item_with_parts = LineItemDouble.example(part_line_items: [
+              PartLineItemDouble.example(variant: VariantDouble.example(sku: "GBB200")),
+              PartLineItemDouble.example(variant: VariantDouble.example(sku: "GSC300")),
+              PartLineItemDouble.example(variant: VariantDouble.example(sku: "GML100"))
+          ])
+          order = OrderDouble.example(line_items: [
+            line_item_with_parts,
+            LineItemDouble.example
+          ])
+          shipment = ShipmentDouble.example(order: order)
+
+          message = ShipmentOrder.new(:shipment => shipment, :client => @client)
+
+          document = Nokogiri::XML::Document.parse(message.to_xml)
+          order_details = document.css('OrderDetails')
+          assert_equal 4, order_details.count
+          assert_equal "GBB200", order_details[0]['ItemNumber']
+          assert_equal "GSC300", order_details[1]['ItemNumber']
+          assert_equal "GML100", order_details[2]['ItemNumber']
+        end
+
+        it "groups duplicate line items together" do
+          phase_2 = LineItemDouble.example(part_line_items: [
+              PartLineItemDouble.example(variant: VariantDouble.example(sku: "GBB200")),
+              PartLineItemDouble.example(variant: VariantDouble.example(sku: "GSC300")),
+              PartLineItemDouble.example(variant: VariantDouble.example(sku: "GML100"))
+          ], quantity: 2)
+          order = OrderDouble.example(line_items: [
+            phase_2,
+            LineItemDouble.example(sku: "GBB200", quantity: 3)
+          ])
+          shipment = ShipmentDouble.example(order: order)
+
+          message = ShipmentOrder.new(:shipment => shipment, :client => @client)
+
+          document = Nokogiri::XML::Document.parse(message.to_xml)
+          order_details = document.css('OrderDetails')
+          assert_equal 3, order_details.count
+          assert_equal "GBB200", order_details[0]['ItemNumber']
+          assert_equal "5", order_details[0]['QuantityOrdered']
+          assert_equal "5", order_details[0]['QuantityToShip']
+        end
+
+      private
+
+        def assert_header(header)
+          assert_equal "#{@shipment.number}", header['OrderNumber']
+          assert_equal @shipment.created_at.utc.iso8601.to_s, header['OrderDate']
+          assert_equal @order.type, header['OrderType']
+        end
+
+        def assert_shipping(shipping)
+          assert_equal 'FEDEX', shipping['Carrier']
+          assert_equal 'GROUND', shipping['ServiceLevel']
+        end
+
+        def assert_line_item(expected_line_item, line_item)
+          assert_equal expected_line_item.sku.to_s, line_item['ItemNumber']
+          assert_equal "1", line_item['Line']
+          assert_equal expected_line_item.quantity.to_s, line_item['QuantityOrdered']
+          assert_equal expected_line_item.quantity.to_s, line_item['QuantityToShip']
+          assert_equal "EA", line_item['UOM']
+          assert_equal expected_line_item.price, line_item['Price']
+        end
+
+        def assert_address(email, address, node)
+          assert_equal address.company, node['Company']
+          assert_equal address.name, node['Contact']
+          assert_equal address.address1, node['Address1']
+          assert_equal address.address2, node['Address2']
+          assert_equal address.city, node['City']
+          assert_equal address.state.name, node['State']
+          assert_equal address.zipcode, node['PostalCode']
+          assert_equal address.country.name, node['Country']
+        end
+
+      end
+    end
+  end
+end