omniorder 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c03ee4b2df4c0589a2a01e7787556544cf5bc382
+  data.tar.gz: e229b29ba52d8c82adc3b083933c6112f8c20011
+SHA512:
+  metadata.gz: ce3a0db160edea671d7c571be7251616f7832cf85d842cd0f54f6ec2f2e389540744ca6c6b023042ad87c53fd56293fad8c5ae14b72d2a3976d4b4da913b4d9d
+  data.tar.gz: 2b70815df33f45e01f465aefec85797e292ef9e33f9caefafba0680f3407194d9acbdc8c4ad4c8ec168daa3eae09986be793ce8be8d8f51baad77e60040bf4f3

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.1.2
+  - 2.0.0
+  - 1.9.3
+  - jruby-1.7.16

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in omniorder.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Howard Wilson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# Omniorder
+
+[![Build Status](http://img.shields.io/travis/watsonbox/omniorder.svg?style=flat)](https://travis-ci.org/watsonbox/omniorder)
+
+Import online orders from various channels for fulfillment.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'omniorder'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install omniorder
+```
+
+
+## Usage
+
+TODO: Write usage instructions here
+
+
+## Contributing
+
+1. Fork it ( https://github.com/watsonbox/omniorder/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/clean'
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+  task :default => [:spec]
+rescue LoadError
+end

data/lib/omniorder/customer.rb

@@ -0,0 +1,7 @@
+module Omniorder
+  class Customer < Entity
+    include Customerable
+
+    attributes :username, :name, :phone, :email, :address1, :address2, :address3, :address4, :postcode, :country
+  end
+end

data/lib/omniorder/customerable.rb

@@ -0,0 +1,42 @@
+module Omniorder
+  module Customerable
+    def username_is_email?
+      username == email
+    end
+
+    def first_names
+      name.split[0...-1]
+    end
+
+    def first_name
+      first_names.first
+    end
+
+    def last_name
+      name.split.last
+    end
+
+    def full_address
+      fields = [address1, address2, address3, address4, postcode, country]
+      fields.reject { |f| f.nil? || f.empty? }.join("\n")
+    end
+
+    def self.get_or_new_from_email(email, attributes = {})
+      customer = nil
+
+      if Omniorder.customer_type.respond_to?(:find_by_email)
+        customer = Omniorder.customer_type.find_by_email(email)
+      end
+
+      if customer
+        attributes.each do |name, value|
+          customer.send("#{name}=", value)
+        end
+      else
+        Omniorder.customer_type.new(attributes)
+      end
+
+      customer
+    end
+  end
+end

data/lib/omniorder/entity.rb

@@ -0,0 +1,21 @@
+module Omniorder
+  class Entity
+    def self.attributes(*attributes)
+      if attributes.empty?
+        instance_variable_get('@attributes')
+      else
+        instance_variable_set('@attributes', attributes)
+        attr_accessor *attributes
+      end
+    end
+
+    def initialize(attributes = {})
+      # Initialize known attributes
+      attributes.each do |attribute, value|
+        if self.class.attributes.include?(attribute.to_sym)
+          send("#{attribute}=", value)
+        end
+      end
+    end
+  end
+end

data/lib/omniorder/import.rb

@@ -0,0 +1,11 @@
+module Omniorder
+  class Import
+    # Allows the import to control how orders are created
+    # e.g. an account could be assigned if system is multi-tennant
+    # Use generate not build so as not to conflict with ActiveRecord
+    # TODO: Move to Importable?
+    def generate_order(attributes = {})
+      Omniorder.order_type.new({ import: self }.merge(attributes))
+    end
+  end
+end

data/lib/omniorder/import_strategy/base.rb

@@ -0,0 +1,50 @@
+module Omniorder
+  module ImportStrategy
+    class Base
+      attr_accessor :import
+      attr_writer :options
+
+      class << self
+        def options(options = nil)
+          if options
+            @options = options
+          else
+            @options || {}
+          end
+        end
+
+        def clear_options
+          @options = nil
+        end
+      end
+
+      def initialize(import, options = {})
+        self.import = import
+        self.options = options
+      end
+
+      # Combines global and local options
+      def options
+        self.class.options.merge(@options)
+      end
+
+      def before_import
+
+      end
+
+      def after_import
+
+      end
+
+      private
+
+      def customer_country_or_default(country)
+        if country.nil? || country.empty?
+          Omniorder.default_customer_country
+        else
+          country
+        end
+      end
+    end
+  end
+end

data/lib/omniorder/import_strategy/groupon.rb

@@ -0,0 +1,93 @@
+module Omniorder
+  module ImportStrategy
+    # Groupon Import Strategy
+    # See: https://scm.commerceinterface.com/api-doc/v2/
+    class Groupon < Base
+      API_URL = "https://scm.commerceinterface.com/api/v2/"
+
+      attr_accessor :supplier_id, :access_token
+
+      def initialize(import, options = {})
+        super
+
+        unless self.supplier_id = options[:supplier_id] and !supplier_id.to_s.empty?
+          raise "Omniorder::ImportStrategy::Groupon requires a supplier_id"
+        end
+
+        unless self.access_token = options[:access_token] and !access_token.to_s.empty?
+          raise "Omniorder::ImportStrategy::Groupon requires an access_token"
+        end
+      end
+
+      def import_orders
+        get_order_info['data'].to_a.each do |order_info|
+          success = yield create_order(order_info)
+
+          if success && options[:mark_exported]
+            result = Crack::JSON.parse do_request(mark_exported_url(order_info), :post)
+
+            unless result['success']
+              raise "Failed to mark Groupon order ##{order_info['orderid']} as exported"
+            end
+          end
+        end
+      end
+
+      def get_orders_url
+        URI.join(API_URL, "get_orders?supplier_id=#{supplier_id}&token=#{access_token}")
+      end
+
+      def mark_exported_url(order_info)
+        lids = order_info['line_items'].map { |li| li["ci_lineitemid"] }
+        URI.join(API_URL, "mark_exported?supplier_id=#{supplier_id}&token=#{access_token}&ci_lineitem_ids=[#{lids.join(',')}]")
+      end
+
+      private
+
+      def create_order(order_info)
+        order = import.generate_order(
+          :order_number => order_info['orderid'],
+          :total_price => order_info['amount']['total'].to_f,
+          :date => DateTime.strptime(order_info['date'], '%m/%d/%Y %I:%M%p UTC')
+        )
+
+        order.customer = create_customer(order, order_info['customer'])
+
+        order_info['line_items'].each do |line_item_info|
+          order.add_product_by_code(line_item_info['sku'].to_s, line_item_info['quantity'].to_i)
+        end
+
+        order
+      end
+
+      def create_customer(order, customer_info)
+        # NOTE: Can't find existing customer as no username or email given
+        order.generate_customer(
+          :name => customer_info['name'],
+          :phone => customer_info['phone'],
+          :address1 => customer_info['address1'],
+          :address2 => customer_info['address2'],
+          :address3 => customer_info['city'],
+          :address4 => customer_info['state'],
+          :postcode => customer_info['zip'].to_s.squeeze(' ').upcase,
+          :country => customer_country_or_default(customer_info['country'])
+        )
+      end
+
+      # NOTE: We don't appear to get an email address for customers
+      def get_order_info
+        Crack::JSON.parse do_request(get_orders_url)
+      end
+
+      private
+
+      def do_request(url, type = :get)
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, 443)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.request((type == :post ? Net::HTTP::Post : Net::HTTP::Get).new(uri.request_uri)).body
+      end
+    end
+  end
+end

data/lib/omniorder/order.rb

@@ -0,0 +1,12 @@
+module Omniorder
+  class Order < Entity
+    include Orderable
+
+    attributes :customer, :order_products, :order_number, :total_price, :date
+
+    def initialize(attributes = {})
+      super
+      self.order_products ||= []
+    end
+  end
+end

data/lib/omniorder/order_product.rb

@@ -0,0 +1,7 @@
+module Omniorder
+  class OrderProduct < Entity
+    include OrderProductable
+
+    attributes :product, :quantity
+  end
+end

data/lib/omniorder/order_productable.rb

@@ -0,0 +1,11 @@
+module Omniorder
+  module OrderProductable
+    def <=>(other)
+      product <=> other.product
+    end
+
+    def to_s
+      quantity.to_s + 'x' + product.code
+    end
+  end
+end

data/lib/omniorder/orderable.rb

@@ -0,0 +1,35 @@
+module Omniorder
+  # Represents common order behavior
+  # Include Omniorder::Orderable in your Order class to make it Omniorder compatible.
+  module Orderable
+    # Use generate not build so as not to conflict with ActiveRecord
+    def generate_customer(attributes = {})
+      Omniorder.customer_type.new(attributes)
+    end
+
+    def add_product(product, quantity = 1)
+      order_product = order_products.to_a.find { |op| op.product == product }
+
+      if order_product.nil?
+        order_products << Omniorder.order_product_type.new(:product => product, :quantity => quantity)
+      else
+        order_product.quantity += quantity
+      end
+    end
+
+    def add_product_by_code(code, quantity = 1)
+      Omniorder.product_type.find_by_code(code).tap do |product|
+        add_product product, quantity unless product.nil?
+      end
+    end
+
+    def product_count
+      order_products.inject(0) { |sum, op| sum + op.quantity }
+    end
+
+    # Human-readable string representing order products
+    def product_list
+      order_products.sort.map(&:to_s).join('/')
+    end
+  end
+end

data/lib/omniorder/product.rb

@@ -0,0 +1,12 @@
+module Omniorder
+  class Product < Entity
+    include Purchasable
+
+    attributes :code
+
+    # This implementation assumes the product to exist
+    def self.find_by_code(code)
+      new(:code => code)
+    end
+  end
+end

data/lib/omniorder/purchasable.rb

@@ -0,0 +1,7 @@
+module Omniorder
+  module Purchasable
+    def <=>(other)
+      code <=> other.code
+    end
+  end
+end

data/lib/omniorder/version.rb

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

data/lib/omniorder.rb

@@ -0,0 +1,55 @@
+require "net/http"
+require "net/https"
+require "crack"
+
+require "omniorder/version"
+require "omniorder/entity"
+require "omniorder/customerable"
+require "omniorder/customer"
+require "omniorder/purchasable"
+require "omniorder/product"
+require "omniorder/orderable"
+require "omniorder/order"
+require "omniorder/order_productable"
+require "omniorder/order_product"
+require "omniorder/import"
+require "omniorder/import_strategy/base"
+require "omniorder/import_strategy/groupon"
+
+module Omniorder
+  class << self
+    attr_writer :order_type
+    attr_writer :order_product_type
+    attr_writer :customer_type
+    attr_writer :product_type
+    attr_writer :default_customer_country
+
+    def order_type
+      @order_type || Order
+    rescue NameError
+      raise "Please set Omniorder#order_type"
+    end
+
+    def customer_type
+      @customer_type || Customer
+    rescue NameError
+      raise "Please set Omniorder#customer_type"
+    end
+
+    def product_type
+      @product_type || Product
+    rescue NameError
+      raise "Please set Omniorder#product_type"
+    end
+
+    def order_product_type
+      @order_product_type || OrderProduct
+    rescue NameError
+      raise "Please set Omniorder#order_product_type"
+    end
+
+    def default_customer_country
+      @default_customer_country || 'United Kingdom'
+    end
+  end
+end

data/omniorder.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'omniorder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "omniorder"
+  spec.version       = Omniorder::VERSION
+  spec.authors       = ["Howard Wilson"]
+  spec.email         = ["howard@watsonbox.net"]
+  spec.summary       = %q{Import online orders from various channels for fulfillment.}
+  spec.description   = %q{Import online orders from various channels for fulfillment.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "crack", "~> 0.4.2"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.1.0"
+  spec.add_development_dependency "webmock", "~> 1.20.4"
+end

data/spec/assets/imports/groupon/base_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Omniorder::ImportStrategy::Base do
+  let(:strategy_class) { Class.new(Omniorder::ImportStrategy::Base) }
+
+  context 'with a global option' do
+    around do |example|
+      strategy_class.options global_option: true
+      example.run
+      strategy_class.clear_options
+    end
+
+    it 'includes the global options' do
+      expect(strategy_class.new(nil, local_option: true).options).to eq(global_option: true, local_option: true)
+    end
+  end
+end

data/spec/assets/imports/groupon/get_orders.json

@@ -0,0 +1,82 @@
+{
+    "meta": {
+        "no_of_pages": 1,
+        "current_page": 1,
+        "max_items_per_page": 250,
+        "no_of_items": 2
+    },
+    "data": [{
+        "orderid": "FFB7A681BE",
+        "customer": {
+            "city": "BRADFORD",
+            "state": "KENT",
+            "name": "SOME BODY HERE",
+            "zip": "SOME ZIP",
+            "country": "UK",
+            "address1": "901",
+            "address2": "GREENFIELDS LANE",
+            "phone": "01234 982103"
+        },
+        "line_items": [{
+            "sku": "03658246",
+            "name": "SOME PACK OF 6",
+            "weight": 0.0,
+            "bom_sku": null,
+            "unit_price": 10.99,
+            "ci_lineitemid": 54553918,
+            "quantity": 3
+        }],
+        "shipping": {
+            "carrier": null,
+            "method": "BEST"
+        },
+        "date": "05/16/2013 08:10AM UTC",
+        "amount": {
+            "total": 10.99,
+            "shipping": 0
+        },
+        "supplier": "SUPPLIER NAME"
+    },
+    {
+            "orderid": "FFB7A68990",
+            "customer": {
+                "city": "BRADFORD",
+                "state": "KENT",
+                "name": "SOME BODY HERE",
+                "zip": "SOME ZIP",
+                "country": "UK",
+                "address1": "901",
+                "address2": "GREENFIELDS LANE",
+                "phone": "01234 982103"
+            },
+            "line_items": [{
+                "sku": "03658246",
+                "name": "SOME PACK OF 6",
+                "weight": 0.0,
+                "bom_sku": null,
+                "unit_price": 10.99,
+                "ci_lineitemid": 54553920,
+                "quantity": 3
+            },
+            {
+                "sku": "03658248",
+                "name": "SOME PACK OF 6",
+                "weight": 0.0,
+                "bom_sku": null,
+                "unit_price": 10.99,
+                "ci_lineitemid": 54553921,
+                "quantity": 2
+            }],
+            "shipping": {
+                "carrier": null,
+                "method": "BEST"
+            },
+            "date": "05/16/2013 10:11AM UTC",
+            "amount": {
+                "total": 10.99,
+                "shipping": 0
+            },
+            "supplier": "SUPPLIER NAME"
+        }],
+    "success": true
+}

data/spec/customerable_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Omniorder::Customerable do
+  let(:customer) { Omniorder::Customer.new }
+
+  describe '#first_name' do
+    it 'is the first name' do
+      customer.name = "Alan Gordon Partridge"
+      expect(customer.first_name).to eq("Alan")
+    end
+  end
+
+  describe '#first_names' do
+    it 'is the first names' do
+      customer.name = "Alan Gordon Partridge"
+      expect(customer.first_names).to eq(["Alan", "Gordon"])
+    end
+  end
+
+  describe '#last_name' do
+    it 'is the last names' do
+      customer.name = "Alan Gordon Partridge"
+      expect(customer.last_name).to eq("Partridge")
+    end
+  end
+
+  describe '#full_address' do
+    it 'should ignore blank address components' do
+      customer.address1 = "29, Sycamore Lane"
+      customer.address3 = "Birmingham"
+      customer.postcode = "B13 8JU"
+      customer.country = "United Kingdom"
+
+      expect(customer.full_address).to eq("29, Sycamore Lane\nBirmingham\nB13 8JU\nUnited Kingdom")
+    end
+  end
+end

data/spec/import_strategy/groupon_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Omniorder::ImportStrategy::Groupon do
+  let(:import) { Omniorder::Import.new }
+  let(:strategy) { Omniorder::ImportStrategy::Groupon.new(import, strategy_options) }
+  let(:strategy_options) { { supplier_id: '1', access_token: 'xYRPKcoakMoiRzWgKLV5TqPSdNAaZQT' } }
+
+  before do
+    stub_request(
+      :get,
+      "https://scm.commerceinterface.com/api/v2/get_orders?supplier_id=1&token=xYRPKcoakMoiRzWgKLV5TqPSdNAaZQT"
+    ).to_return(
+      body: File.new('spec/assets/imports/groupon/get_orders.json'),
+      status: 200
+    )
+  end
+
+  context 'no supplier_id is supplied' do
+    let(:strategy_options) { { access_token: 'xYRPKcoakMoiRzWgKLV5TqPSdNAaZQT' } }
+
+    it 'raises an exception' do
+      expect { strategy }.to raise_exception "Omniorder::ImportStrategy::Groupon requires a supplier_id"
+    end
+  end
+
+  context 'no access_token is supplied' do
+    let(:strategy_options) { { supplier_id: '1' } }
+
+    it 'raises an exception' do
+      expect { strategy }.to raise_exception "Omniorder::ImportStrategy::Groupon requires an access_token"
+    end
+  end
+
+  it 'imports orders with products and a customer' do
+    orders = []
+    strategy.import_orders { |o| orders << o }
+
+    order = orders.first
+    expect(order.order_number).to eq("FFB7A681BE")
+    expect(order.total_price).to eq(10.99)
+    expect(order.date.to_s).to eq("2013-05-16T08:10:00+00:00")
+    expect(order.order_products.count).to eq(1)
+
+    order_product = order.order_products.first
+    expect(order_product.quantity).to eq(3)
+    expect(order_product.product.code).to eq('03658246')
+
+    customer = order.customer
+    expect(customer.name).to eq("SOME BODY HERE")
+    expect(customer.phone).to eq("01234 982103")
+    expect(customer.address1).to eq("901")
+    expect(customer.address2).to eq("GREENFIELDS LANE")
+    expect(customer.address3).to eq("BRADFORD")
+    expect(customer.address4).to eq("KENT")
+    expect(customer.postcode).to eq("SOME ZIP")
+    expect(customer.country).to eq("UK")
+  end
+
+  context 'the mark_exported option is set' do
+    let(:strategy_options) { { supplier_id: '1', access_token: 'xYRPKcoakMoiRzWgKLV5TqPSdNAaZQT', mark_exported: true } }
+
+    let(:mark_exported_result) { '{ "success": true }' }
+    let!(:mark_exported_stub) do
+      stub_request(
+        :post,
+        "https://scm.commerceinterface.com/api/v2/mark_exported?supplier_id=1&token=xYRPKcoakMoiRzWgKLV5TqPSdNAaZQT&ci_lineitem_ids=[54553920,54553921]"
+      ).to_return(
+        body: mark_exported_result,
+        status: 200
+      )
+    end
+
+    it 'marks orders as exported when the order handler is truthy' do
+      strategy.import_orders { |o| true if o.order_number == "FFB7A68990" }
+      expect(mark_exported_stub).to have_been_requested.once
+    end
+
+    context "mark exported API call fails" do
+      let(:mark_exported_result) { '{ "success": false }' }
+
+      it 'raises an exception' do
+        expect {
+          strategy.import_orders { |o| true if o.order_number == "FFB7A68990" }
+        }.to raise_exception "Failed to mark Groupon order #FFB7A68990 as exported"
+      end
+    end
+  end
+end

data/spec/orderable_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Omniorder::Orderable do
+  let(:product1) { Omniorder::Product.new(:code => 'CODE1') }
+  let(:product2) { Omniorder::Product.new(:code => 'CODE2') }
+  let(:order) { Omniorder::Order.new }
+
+  before do
+    allow(Omniorder::Product).to receive(:find_by_code)
+      .with('CODE1')
+      .and_return(product1)
+
+    allow(Omniorder::Product).to receive(:find_by_code)
+      .with('CODE2')
+      .and_return(product2)
+  end
+
+  describe '#add_product_by_code' do
+    it 'adds a product to the order when one is found' do
+      order.add_product_by_code('CODE1')
+
+      order_product = order.order_products.first
+      expect(order_product.quantity).to eq(1)
+      expect(order_product.product).to eq(product1)
+    end
+
+    it 'does nothing when no matching product is found' do
+      expect(Omniorder::Product).to receive(:find_by_code)
+        .with('CODE1')
+        .and_return(nil)
+
+      order.add_product_by_code('CODE1')
+
+      expect(order.order_products.count).to eq(0)
+    end
+  end
+
+  describe '#product_count' do
+    it 'is the sum of all attached product quantities' do
+      order.add_product_by_code('CODE1', 10)
+      order.add_product_by_code('CODE2', 6)
+
+      expect(order.product_count).to eq(16)
+    end
+  end
+
+  describe '#product_list' do
+    it 'is a human-readable string representing order products' do
+      order.add_product_by_code('CODE1', 10)
+      order.add_product_by_code('CODE2', 6)
+
+      expect(order.product_list).to eq('10xCODE1/6xCODE2')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'webmock/rspec'
+require 'omniorder'
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: omniorder
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Howard Wilson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: crack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.20.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.20.4
+description: Import online orders from various channels for fulfillment.
+email:
+- howard@watsonbox.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/omniorder.rb
+- lib/omniorder/customer.rb
+- lib/omniorder/customerable.rb
+- lib/omniorder/entity.rb
+- lib/omniorder/import.rb
+- lib/omniorder/import_strategy/base.rb
+- lib/omniorder/import_strategy/groupon.rb
+- lib/omniorder/order.rb
+- lib/omniorder/order_product.rb
+- lib/omniorder/order_productable.rb
+- lib/omniorder/orderable.rb
+- lib/omniorder/product.rb
+- lib/omniorder/purchasable.rb
+- lib/omniorder/version.rb
+- omniorder.gemspec
+- spec/assets/imports/groupon/base_spec.rb
+- spec/assets/imports/groupon/get_orders.json
+- spec/customerable_spec.rb
+- spec/import_strategy/groupon_spec.rb
+- spec/orderable_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Import online orders from various channels for fulfillment.
+test_files:
+- spec/assets/imports/groupon/base_spec.rb
+- spec/assets/imports/groupon/get_orders.json
+- spec/customerable_spec.rb
+- spec/import_strategy/groupon_spec.rb
+- spec/orderable_spec.rb
+- spec/spec_helper.rb