peddler 0.3.1 → 0.4.1

data/lib/peddler/inventory.rb

@@ -1,140 +0,0 @@
-module Peddler
-  module Inventory
-    module Queue
-      # Returns number of inventory uploads queued at Amazon
-      def self.count(transport)
-        transport.legacize_request
-        transport.path << 'manual-reports/get-pending-uploads-count'
-        res = transport.execute_request
-        if res =~ /^<PendingUploadsCount>(.*)<\/PendingUploadsCount>$/
-          $1.to_i
-        else
-          nil
-        end
-      end
-    end
-
-    # This is an inventory batch.
-    class Batch
-      attr_reader :id
-      attr_accessor :batch
-
-      def initialize(transport)
-        @transport = transport
-        @batch = []
-      end
-
-      # Uploads batch to Amazon.
-      def upload(params={})
-        raise PeddlerError.new('Batch already uploaded') unless @id.nil?
-        @transport.legacize_request
-        @transport.path << 'catalog-upload/'
-
-        case params[:method].to_s
-        when 'modify'
-          @transport.path << 'modify-only'
-          @transport.body = file_content(:short)
-        when 'purge'
-          @transport.path << 'purge-replace'
-          @transport.body = file_content
-        else
-          @transport.path << 'add-modify-delete'
-          @transport.body = file_content
-        end
-        params.delete(:method)
-
-        params = defaultize(params)
-        @transport.headers.merge!(params)
-        res = @transport.execute_request
-
-        if res =~ /^<BatchID>(.*)<\/BatchID>$/
-          @id = $1
-        else
-          @id = 0
-        end
-        true
-      end
-
-      # Returns upload file string.
-      def file_content(type=:long)
-        case type
-        when :long
-          out = "product-id\tproduct-id-type\titem-condition\tprice\tsku\tquantity\tadd-delete\twill-ship-internationally\texpedited-shipping\titem-note\titem-is-marketplace\tfulfillment-center-id\titem-name\titem-description\tcategory1\timage-url\tshipping-fee\tbrowse-path\tstorefront-feature\tboldface\tasin1\tasin2\tasin3\r\n"
-          @batch.each{ |item| out << item.to_s }
-        when :short
-          out = "sku\tprice\tquantity\r\n"
-          @batch.each{ |item| out << item.to_s(:short) }
-        end
-        out
-      end
-
-      # Adds an item to inventory.
-      def <<(item)
-        @batch << item
-      end
-
-      private
-
-      def defaultize(params)
-        params = {
-          :upload_for         => 'Marketplace',
-          :file_format        => 'TabDelimited',
-          :asin_match_create  => 'Y',
-          :asinate            => 'Y',
-          :batch_id           => 'Y',
-          :email              => 'Y'
-        }.merge(params)
-
-        # Some Amazon dimwit figured he'd rather not camelize this one
-        if params[:enable_expedited_shipping]
-          params['enable-expedited-shipping'] = params[:enable_expedited_shipping]
-          params.delete(:enable_expedited_shipping)
-        else
-          params['enable-expedited-shipping'] = 'Y'
-        end
-
-        params
-      end
-    end
-
-    # This is an inventory item.
-    class Item
-      attr_accessor :product_id,
-                    :product_id_type,
-                    :item_condition,
-                    :price,
-                    :sku,
-                    :quantity,
-                    :add_delete,
-                    :will_ship_internationally,
-                    :expedited_shipping,
-                    :item_note,
-                    :item_is_marketplace,
-                    :fulfillment_center_id,
-                    :item_name,
-                    :item_description,
-                    :category1,
-                    :image_url,
-                    :shipping_fee,
-                    :browse_path,
-                    :storefront_feature,
-                    :boldface,
-                    :asin1,
-                    :asin2,
-                    :asin3
-
-      def initialize(params={})
-        params.each_pair{ |key, value| send("#{key.to_s}=", value) }
-      end
-
-      def to_s(type=:long)
-        case type
-        when :long
-          "#{self.product_id}\t#{self.product_id_type}\t#{self.item_condition}\t#{self.price}\t#{self.sku}\t#{self.quantity}\t#{self.add_delete}\t#{self.will_ship_internationally}\t#{self.expedited_shipping}\t#{self.item_note}\t#{self.item_is_marketplace}\t#{self.fulfillment_center_id}\t#{self.item_name}\t#{self.item_description}\t#{self.category1}\t#{self.image_url}\t#{self.shipping_fee}\t#{self.browse_path}\t#{self.storefront_feature}\t#{self.boldface}\t#{self.asin1}\t#{self.asin2}\t#{self.asin3}\r\n"
-        when :short
-          "#{self.sku}\t#{self.price}\t#{self.quantity}\r\n"
-        end
-      end
-    end
-  end
-end

data/lib/peddler/legacy_reports.rb

@@ -1,109 +0,0 @@
-module Peddler
-
-  # This module contains methods to manage legacy reports -- anything that comes before section 7 in the API docs.
-  module LegacyReports
-
-    # Returns statuses of most recent reports in an array of OpenStructs.
-    def self.latest(transport,name,params={})
-      transport.legacize_request
-      if name == :upload
-        transport.path << 'catalog-upload/get-batches'
-        transport.headers[:number_of_batches] = params[:count] if params[:count]
-      else
-        transport.path << 'manual-reports/get-report-status'
-        transport.headers[:report_name] = name.to_s.camelize
-        transport.headers[:number_of_reports] = params[:count] if params[:count]
-      end
-      res = transport.execute_request
-      Peddler::Handlers::XMLHandler.parse_legacy(Hash.from_xml(res)) || []
-    end
-
-    # Requests a report to be generated and returns the report instance if request is successful.
-    def self.generate(transport,name,params={})
-      transport.legacize_request
-      transport.path << 'manual-reports/generate-report-now'
-      transport.headers[:report_name] = name.to_s.camelize
-      transport.headers.merge!(params)
-      res = transport.execute_request
-      res =~ /SUCCESS/ ? Peddler::LegacyReports::Report.new(transport, name) : false
-    end
-
-    # A legacy report
-    class Report
-      attr_accessor :name, :id, :product_line, :frequency
-
-      def initialize(transport, name=nil, params={})
-        @transport, @name = transport, name
-        params.each_pair{ |key, value| self.send "#{key}=", value }
-      end
-
-      def body
-        return nil if @name == :upload && @id.nil?
-        @body ||= download
-      end
-
-      private
-
-      def download
-        return false if @name.nil? && @id.nil?
-        case @name.to_s
-        when 'upload'
-          @transport.legacize_request
-          @transport.path << 'download/errorlog'
-          @transport.headers['BatchID'] = @id
-          @transport.execute_request
-        else
-          @transport.legacize_request
-          @transport.path << 'download/report'
-          if @id.nil?
-            @transport.headers[:report_name] = @name.to_s.camelize
-            if @name == :preorder
-              @transport.headers['productline'] = @product_line if @product_line
-              @transport.headers['frequency'] = @frequency if @frequency
-            end
-          else
-            @transport.headers['ReportID'] = @id
-          end
-          @transport.execute_request
-        end
-      end
-    end
-
-    class Status < OpenStruct
-      def initialize(input)
-        if input.kind_of? String
-          hash = input.scan(/([a-z]+)=([^=]+)($| )/).inject({}){ |memo, value| memo.merge( { @keymap[value[0]] => value[1].strip }) }
-        end
-        super(hash)
-      end
-
-      def id
-        @table[:id] || self.object_id
-      end
-    end
-
-    class ReportStatus < Status
-      def initialize(input)
-        @keymap = {
-          'reportstarttime' => 'starts_at',
-          'reportendtime'   => 'ends_at',
-          'reportid'        => 'id' }
-        super(input)
-      end
-    end
-
-    class UploadStatus < Status
-      def initialize(input)
-        @keymap = {
-          'status'            => 'status',
-          'batchid'           => 'id',
-          'numberofwarnings'  => 'number_of_warnings',
-          'activateditems'    => 'activated_items',
-          'itemsnotacivated'  => 'items_not_activated',
-          'itemsnotactivated' => 'items_not_activated',
-          'dateandtime'       => 'datetime' }
-        super(input)
-      end
-    end
-  end
-end

data/lib/peddler/refunds.rb

@@ -1,52 +0,0 @@
-module Peddler
-  module Refunds
-    # This is a refund batch.
-    class Batch
-      attr_accessor :batch
-
-      def initialize(transport)
-        @transport = transport
-        @batch = []
-      end
-
-      def file_content
-        out = "order-id\tpayments-transaction-id\trefund-amount\treason\tmessage\r\n"
-        @file_content = @batch.inject(out){ |memo, item| memo << item.to_s }
-      end
-
-      def <<(item)
-        @batch << item
-      end
-
-      def upload
-        raise PeddlerError.new("Batch already uploaded") if @completed
-        @transport.legacize_request
-        @transport.path << "catalog-upload/batch-refund"
-        @transport.body = file_content
-        res = @transport.execute_request
-        @completed = true if res == "<Success>SUCCESS</Success>"
-      end
-
-    end
-
-    # This is a refund.
-    class Item
-      REFUND_REASONS = %w{ GeneralAdjustment CouldNotShip DifferentItem MerchandiseNotReceived MerchandiseNotAsDescribed }
-
-      attr_accessor :order_id, :payments_transaction_id, :refund_amount, :message
-      attr_reader   :reason
-
-      def initialize(options={})
-        options.each_pair{ |key, value| send("#{key.to_s}=", value) }
-      end
-
-      def reason=(reason)
-        @reason = reason if REFUND_REASONS.include?(reason)
-      end
-
-      def to_s
-        "#{self.order_id}\t#{self.payments_transaction_id}\t#{self.refund_amount}\t#{self.reason}\t#{self.message}\r\n"
-      end
-    end
-  end
-end

data/lib/peddler/transport.rb

@@ -1,135 +0,0 @@
-module Peddler
-  class PeddlerError < StandardError
-    def initialize(msg)
-      super(msg)
-    end
-  end
-
-  # Our work horse. Runs on top of Net::HTTP.
-  class Transport
-    API_HOSTS = {
-      :us => 'secure.amazon.com',
-      :uk => 'secure.amazon.co.uk',
-      :de => 'secure.amazon.de',
-      :ca => 'secure.amazon.ca',
-      :fr => 'secure.amazon.fr',
-      :jp => 'vendornet.amazon.co.jp'
-    }
-
-    BASE_HEADERS  = {
-      'User-Agent'    => "Peddler/#{Peddler::VERSION}",
-      'Content-Type'  => 'text/xml;charset=utf-8',
-      'Cookie'        => 'x-main=YvjPkwfntqDKun0QEmVRPcTTZDMe?Tn?; ubid-main=002-8989859-9917520; ubid-tacbus=019-5423258-4241018;x-tacbus=vtm4d53DvX@Sc9LxTnAnxsFL3DorwxJa; ubid-tcmacb=087-8055947-0795529; ubid-ty2kacbus=161-5477122-2773524; session-id=087-178254-5924832;session-id-time=950660664'
-    }
-
-    BASE_PARAMS = {
-      'Service' => 'MerchantQueryService'
-    }
-
-    attr_writer   :username, :password
-    attr_accessor :path, :query_params, :headers, :body
-
-    #Returns request instance
-    def request
-      req = request_method.new("#{path.gsub(/\/$/, "")}/#{query_string}")
-      headers.each do |header, value|
-        if header.kind_of? Symbol
-          req[header.to_s.gsub(/_/, '')] = value
-        else
-          req[header] = value
-        end
-      end
-      req.basic_auth(@username, @password) if @username && @password
-      req.body = body if body
-      req
-    end
-
-    def execute_request
-      begin
-        conn.start do |http|
-          res = http.request(request)
-          case res
-          when Net::HTTPSuccess
-            res.body
-          else
-            raise PeddlerError.new(res.body)
-          end
-        end
-      end
-    end
-
-    def clear_request
-      self.headers = BASE_HEADERS.dup
-      self.body = nil
-    end
-
-    def legacize_request
-      clear_request
-      self.path = '/exec/panama/seller-admin/'
-      self.query_params = {}
-    end
-
-    def modernize_request
-      clear_request
-      self.path = '/query/'
-      self.query_params = BASE_PARAMS.dup
-    end
-
-    def region=(region)
-      @conn = nil
-      region = region.to_sym
-      if API_HOSTS.has_key?(region)
-        @region = region
-      else
-        raise PeddlerError.new('Region not recognized')
-      end
-    end
-
-    def url
-      URI.parse("https://#{host}#{path}#{query_string}")
-    end
-
-    def dump_headers(msg)
-      msg.each_header do |k, v|
-        p "#{k}=#{v}"
-      end
-    end
-
-    private
-
-    #Returns the Net::HTTP instance.
-    def conn
-      if @conn
-        @conn
-      else
-        conn = Net::HTTP.new(host, 443)
-        conn.use_ssl = true
-        conn.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        @conn = conn
-      end
-    end
-
-    def request_method
-      if !body.nil? || (query_params && !query_params.empty?)
-        Net::HTTP::Post
-      else
-        Net::HTTP::Get
-      end
-    end
-
-    def host
-      API_HOSTS[@region]
-    end
-
-    def query_string
-      if query_params && !query_params.empty?
-        params = query_params.collect do |k, v|
-          k = k.to_s.gsub(/_([a-z])/) { $1.upcase } if k.kind_of? Symbol
-          v = v.httpdate if v.respond_to? :httpdate
-          "#{k}=#{v}"
-        end
-        "?#{params.join('&')}"
-      end
-    end
-  end
-end

data/peddler.gemspec

@@ -1,28 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path('../lib', __FILE__)
-require 'peddler/version'
-
-Gem::Specification.new do |s|
-  s.name        = 'peddler'
-  s.version     = Peddler::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Hakan Ensari']
-  s.email       = ['hakan.ensari@papercavalier.com']
-  s.homepage    = 'http://github.com/papercavalier/peddler'
-  s.summary     = %q{A Ruby wrapper to the Amazon Inventory Management API}
-  s.description = %q{Peddler is a Ruby wrapper to the Amazon Inventory Management API.}
-
-  s.rubyforge_project = 'peddler'
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ['lib']
-
-  s.add_dependency 'activesupport', '>= 2.3.2'
-  s.add_development_dependency 'rdiscount', '~> 1.6.5'
-  s.add_development_dependency 'sdoc-helpers', '~> 0.1.4'
-  s.add_development_dependency 'rspec', '~> 2.0.0'
-  s.add_development_dependency 'vcr', '~> 1.2.0'
-  s.add_development_dependency 'webmock', '~> 1.4.0'
-end

data/spec/peddler/client_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-module Peddler
-  describe Client do 
-    let(:client) do
-      Peddler::Client.new(
-        :username => 'seller@example.com',
-        :password => 'secret',
-        :region   => 'us'
-      )
-    end
-
-    it "returns a new inventory batch" do
-      client.new_inventory_batch.should be_an_instance_of Peddler::Inventory::Batch
-    end
-
-    it "returns a new inventory item" do
-      client.new_inventory_item.should be_an_instance_of Peddler::Inventory::Item
-    end
-
-    it "returns a new order fulfillment feed" do
-      client.new_order_fulfillment_feed.should be_an_instance_of Peddler::Feeds::OrderFulfillment::Batch
-    end
-
-    it "returns a new fulfilled order" do
-      client.new_fulfilled_order.should be_an_instance_of Peddler::Feeds::OrderFulfillment::Item
-    end
-
-    it "returns a new order cancellation feed" do
-      client.new_order_cancellation_feed.should be_an_instance_of Peddler::Feeds::OrderCancellation::Batch
-    end
-
-    it "returns a new cancelled order" do
-      client.new_cancelled_order.should be_an_instance_of Peddler::Feeds::OrderCancellation::Item
-    end
-
-    it "returns a new refund batch" do
-      client.new_refund_batch.should be_an_instance_of Peddler::Refunds::Batch
-    end
-
-    it "returns a new report" do
-      client.new_report(:foo).should be_an_instance_of Peddler::LegacyReports::Report
-    end
-  end
-end 

data/spec/peddler/feeds_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-module Peddler
-  module Feeds
-    module OrderFulfillment
-      describe Batch do
-        let(:transport) do
-          transport = Peddler::Transport.new
-          transport.modernize_request
-          transport
-        end
-
-        let(:feed) { Peddler::Feeds::OrderFulfillment::Batch.new(transport) }
-
-        let(:fulfilled_order) do
-          Peddler::Feeds::OrderFulfillment::Item.new(
-            :order_id  => '123-1234567-1234567',
-            :ship_date => Date.parse('2009-08-11').to_s
-          )
-        end
-
-        it 'adds items to batch' do
-          feed.batch.size.should == 0
-          feed << fulfilled_order
-          feed.batch.size.should == 1
-        end
-
-        it 'creates content for upload' do
-          feed << fulfilled_order
-          feed.file_content.should == "order-id\torder-item-id\tquantity\tship-date\tcarrier-code\tcarrier-name\ttracking-number\tship-method\r\n123-1234567-1234567\t\t\t2009-08-11\t\t\t\t\r\n"
-        end
-
-        it 'uploads' do
-          feed.id.should == nil
-          transport.stub!(:execute_request).and_return('<?xml version="1.0" encoding="UTF-8"?><Response xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://merchant-query.amazon.com/query/schema/MerchantQueryResponses.xsd"><Upload> <UploadId>130895733</UploadId><UploadType>_POST_FLAT_FILE_FULFILLMENT_DATA_</UploadType><UploadStatus>_SUBMITTED_</UploadStatus><SubmittedDate>2007-04-05T00:34:00+0000</SubmittedDate></Upload></Response>')
-          feed.upload
-          feed.id.should == '130895733'
-          feed.status.should == '_SUBMITTED_'
-        end
-
-        it 'refreshes status' do
-          transport.stub!(:execute_request).and_return('<?xml version="1.0" encoding="UTF-8"?><Response xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://merchant-query.amazon.com/query/schema/MerchantQueryResponses.xsd"><Upload> <UploadId>130895733</UploadId><UploadType>_POST_FLAT_FILE_FULFILLMENT_DATA_</UploadType><UploadStatus>_SUBMITTED_</UploadStatus><SubmittedDate>2007-04-05T00:34:00+0000</SubmittedDate></Upload></Response>')
-          feed.upload
-          transport.stub!(:execute_request).and_return('<?xml version="1.0" encoding="UTF-8"?><Response xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://merchant-query.amazon.com/query/schema/MerchantQueryResponses.xsd"><UploadsStatusList><Upload><UploadId>130895733</UploadId><UploadType>_POST_FLAT_FILE_FULFILLMENT_DATA_</UploadType><UploadStatus>_IN_PROGRESS_</UploadStatus><SubmittedDate>2007-04-05T00:34:00+0000</SubmittedDate><StartedProcessingDate>2007-04-05T00:39:00+0000</StartedProcessingDate></Upload></UploadsStatusList></Response>')
-          feed.status.should == '_SUBMITTED_'
-          feed.status!.should == '_IN_PROGRESS_'
-          transport.stub!(:execute_request).and_return('<?xml version="1.0" encoding="UTF-8"?><Response xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://merchant-query.amazon.com/query/schema/MerchantQueryResponses.xsd"><UploadsStatusList><Upload><UploadId>130895733</UploadId><UploadType>_POST_FLAT_FILE_FULFILLMENT_DATA_</UploadType><UploadStatus>_DONE_</UploadStatus><SubmittedDate>2007-04-05T00:34:00+0000</SubmittedDate><StartedProcessingDate>2007-04-05T00:39:00+0000</StartedProcessingDate><CompletedProcessingDate>2007-04-05T01:02:00+0000</CompletedProcessingDate><MessagesProcessed>2</MessagesProcessed><MessagesSuccessful>2</MessagesSuccessful><MessagesWithErrors>0</MessagesWithErrors><MessagesWithWarnings>0</MessagesWithWarnings><RelatedDownloadsList><Download><DownloadId>3404021</DownloadId><DownloadType>FeedSummaryReport</DownloadType><RelatedReferenceId>4307285844</RelatedReferenceId><AvailableDate>2009-04-24T23:47:24+00:00</AvailableDate><Acknowledged>FALSE</Acknowledged></Download></RelatedDownloadsList></Upload></UploadsStatusList></Response>')
-          feed.status!.should == '_DONE_'
-          feed.download.id.should == '3404021'
-          feed.download.available_at.should == '2009-04-24T23:47:24+00:00'
-        end
-      end
-    end
-
-    module OrderCancellation
-      describe Batch do
-        let(:transport) do
-          transport = Peddler::Transport.new
-          transport.modernize_request
-          transport
-        end
-        let(:feed) { Peddler::Feeds::OrderCancellation::Batch.new(transport) }
-        let(:cancelled_order) { Peddler::Feeds::OrderCancellation::Item.new(:order_id  => '123-1234567-1234567') }
-
-        it 'adds items to batch' do
-          feed.batch.size.should == 0
-          feed << cancelled_order
-          feed.batch.size.should == 1
-        end
-
-        it 'creates content for upload' do
-          feed << cancelled_order
-          feed.file_content.should == "TemplateType=OrderCancellation  Version=1.0/1.0.3 This row for Amazon.com use only.  Do not modify or delete.\r\norder-id\tcancellation-reason-code\tamazon-order-item-code\r\n123-1234567-1234567\t\t\r\n"
-        end
-
-        it 'raises error if cancellation reason code is given but Amazon order item code is missing' do
-          cancelled_order.cancellation_reason_code = 'BuyerCanceled'
-          lambda { cancelled_order.to_s }.should raise_error(PeddlerError)
-        end
-
-        it 'raises error if Amazon order item code is given but cancellation reason code is missing' do
-          cancelled_order.amazon_order_item_code = '111111111111'
-          lambda { cancelled_order.to_s }.should raise_error(PeddlerError)
-        end
-      end
-    end
-  end
-end 

data/spec/peddler/handlers_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-module Peddler
-  module Handlers    
-    describe TabDelimitedHandler do
-      it "parses tab-delimited text" do
-        text = Peddler::Handlers::TabDelimitedHandler.decode_response("title\tautor\nA Thousand Plateaus\tGilles Deleuze\n")
-        text[0].title.should == 'A Thousand Plateaus'
-      end
-    end
-  end
-end 

data/spec/peddler/inventory_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-module Peddler
-  module Inventory
-    describe Queue do
-      it 'shows queue count' do
-        transport = Peddler::Transport.new
-        transport.legacize_request
-        transport.stub!(:execute_request).and_return('<PendingUploadsCount>1</PendingUploadsCount>')
-        Peddler::Inventory::Queue.count(transport).should == 1
-      end
-    end
-
-    describe Batch do 
-      let(:transport) do
-        transport = Peddler::Transport.new
-        transport.legacize_request
-        transport
-      end
-
-      let(:inventory) { Peddler::Inventory::Batch.new(transport) }
-      let(:item) do
-        Peddler::Inventory::Item.new(
-          :product_id => '1234567890',
-          :price      => 100.00,
-          :sku        => 'FOO-SKU',
-          :quantity   => 10
-        )
-      end
-
-      it 'adds items to batch' do
-        inventory.batch.size.should == 0
-        inventory << item
-        inventory.batch.size.should == 1
-      end
-
-      it 'generates an upload file' do
-        inventory << item
-        inventory.file_content.should == "product-id\tproduct-id-type\titem-condition\tprice\tsku\tquantity\tadd-delete\twill-ship-internationally\texpedited-shipping\titem-note\titem-is-marketplace\tfulfillment-center-id\titem-name\titem-description\tcategory1\timage-url\tshipping-fee\tbrowse-path\tstorefront-feature\tboldface\tasin1\tasin2\tasin3\r\n1234567890\t\t\t100.0\tFOO-SKU\t10\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\r\n"
-      end
-
-      it 'generates a modify-only upload file' do
-        inventory << item
-        inventory.file_content(:short).should == "sku\tprice\tquantity\r\nFOO-SKU\t100.0\t10\r\n"
-      end
-
-      it 'generates default headers for uploading' do
-        params = inventory.send(:defaultize,
-          :file_format => 'UIEE',
-          :enable_expedited_shipping => 'N'
-        )
-        params[:method].should be_nil
-        params[:upload_for].should == 'Marketplace'
-        params[:email].should == 'Y'
-        params[:file_format].should == 'UIEE'
-        params['enable-expedited-shipping'].should == 'N'
-        params[:enable_expedited_shipping].should be_nil
-      end
-
-      it 'uploads batch' do
-        transport.stub!(:execute_request).and_return('<BatchID>2585199250</BatchID>')
-        inventory.upload.should == true
-        inventory.id.should == '2585199250'
-      end
-
-      it 'raises error if a subsequent upload is attempted' do
-        transport.stub!(:execute_request).and_return('<BatchID>2585199250</BatchID>')
-        inventory.upload.should == true
-        inventory.id.should_not == nil
-        lambda { inventory.upload }.should raise_error(PeddlerError)
-      end
-    end
-  end
-end