collector-ruby 0.1.1

data/lib/collector/invoice_response.rb

@@ -0,0 +1,27 @@
+require 'representable/hash'
+
+module Collector
+  class InvoiceResponse < BaseModel
+    swallow_unsupported_attributes  # Accept unknown attributes returned from service
+
+    attributes_opt :available_reservation_amount, :correlation_id, :due_date,
+                  :invoice_no, :invoice_status, :invoice_url,
+                  :lowest_amount_to_pay, :payment_reference, :total_amount,
+                  :new_invoice_no
+  end
+
+  class InvoiceResponseRepresenter < Representable::Decorator
+    include Representable::Hash
+
+    property :available_reservation_amount
+    property :correlation_id
+    property :due_date
+    property :invoice_no
+    property :invoice_status
+    property :invoice_url
+    property :lowest_amount_to_pay
+    property :new_invoice_no
+    property :payment_reference
+    property :total_amount
+  end
+end

data/lib/collector/invoice_row.rb

@@ -0,0 +1,18 @@
+require 'representable/hash'
+
+module Collector
+  class InvoiceRow < BaseModel
+    attributes :article_id, :description, :quantity, :unit_price, :vat
+  end
+
+  class InvoiceRowRepresenter < Representable::Decorator
+    include Representable::Hash
+
+    property :article_id,   as: "ArticleId"
+    property :description,  as: "Description"
+    property :quantity,     as: "Quantity"
+    property :unit_price,   as: "UnitPrice"
+    property :vat,          as: "VAT"
+  end
+
+end

data/lib/collector/replace_invoice_request.rb

@@ -0,0 +1,31 @@
+require 'representable/hash'
+require 'representable/hash/collection'
+
+module Collector
+  class ReplaceInvoiceRequest < BaseModel
+
+    attributes :invoice_no, :invoice_rows,
+                :store_id, :country_code
+    attributes_opt :correlation_id
+  end
+
+  class ReplaceInvoiceRequestRepresenter < Representable::Decorator
+    include Representable::Hash
+
+    self.representation_wrap = "ReplaceInvoiceRequest"
+
+    property   :correlation_id,  as: "CorrelationId"
+    property   :country_code,    as: "CountryCode"
+    property   :invoice_no,      as: "InvoiceNo"
+    property   :invoice_rows,
+                  writer: lambda {|doc, args|
+                    doc["InvoiceRows"] = InvoiceRowListRepresenter.new(invoice_rows).to_hash
+                  },
+                  reader: lambda {|doc, args|
+                    rows = doc["InvoiceRows"]["InvoiceRow"]
+                    self.invoice_rows = rows.map{|row| InvoiceRowRepresenter.new(InvoiceRow.new).from_hash(row) }
+                  }
+    property   :store_id,        as: "StoreId"
+  end
+
+end

data/lib/collector/user.rb

@@ -0,0 +1,25 @@
+require 'representable/hash'
+
+module Collector
+  class User < BaseModel
+    swallow_unsupported_attributes
+
+    attributes :first_name, :last_name, :reg_no, :addresses
+  end
+
+  class UserRepresenter < Representable::Decorator
+    include Representable::Hash
+
+    property    :first_name,        as: :firstname
+    property    :last_name,         as: :lastname
+    property    :reg_no
+    property    :addresses,
+                reader: lambda {|doc, args|
+                  addresses = doc[:addresses]
+                  doc[:addresses] = [addresses] unless addresses.kind_of? Array
+                  self.addresses = addresses.map{|key, adr|
+                    key == "base_address" ? Address.new(adr) : nil
+                  }.compact
+                }
+  end
+end

data/lib/collector/version.rb

@@ -0,0 +1,3 @@
+module Collector
+  VERSION = "0.1.1"
+end

data/spec/address_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Collector::Address do
+  let (:address_hash) {
+    { address1: "Storgatan",
+      city: "Njutånger",
+      country_code: "SE",
+      postal_code: "90737",
+      first_name: "Svenne",
+      last_name: "Banan"}
+  }
+  it "can be constructed from a hash" do
+    address = Collector::Address.new( address_hash )
+    address.address1.should eq "Storgatan"
+    address.city.should eq "Njutånger"
+    address.country_code.should eq "SE"
+    address.postal_code.should eq "90737"
+    address.first_name.should eq "Svenne"
+    address.last_name.should eq "Banan"
+  end
+
+  it "converts to hash and back without losing information" do
+    obj = Collector::Address.new( address_hash )
+    hash = Collector::AddressRepresenter.new(obj).to_hash
+    obj2 = Collector::Address.new
+    Collector::AddressRepresenter.new(obj2).from_hash(hash)
+    obj2.should eq obj
+  end
+
+  it "reports that all required attributes are present if they are" do
+    full_address = Collector::Address.new( address_hash )
+    full_address.should have_required_attributes
+    full_address.missing_attributes.should be_empty
+  end
+
+  it "reports missing attributes" do
+    incomplete = address_hash.dup
+    incomplete.delete(:address1)
+    incomplete.delete(:postal_code)
+    incomplete_address = Collector::Address.new( incomplete )
+    incomplete_address.should_not have_required_attributes
+    incomplete_address.missing_attributes.should eq [:address1, :postal_code]
+  end
+
+end

data/spec/article_list_item_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Collector::ArticleListItem do
+  let (:article_list_item_hash) {
+    { "article_id" => "123",
+      "description" => "A fine piece",
+      "quantity" => "23",
+    }
+  }
+  it "can be constructed from a hash" do
+    aticle = Collector::ArticleListItem.new( article_list_item_hash )
+    aticle.article_id.should eq "123"
+    aticle.description.should eq "A fine piece"
+    aticle.quantity.should eq "23"
+  end
+
+  it "can be constructed from an InvoiceRow instance" do
+    invoice_row = Collector::InvoiceRow.new(sandbox_invoice_row_hash)
+    article = Collector::ArticleListItem.new( invoice_row )
+    article.article_id.should eq "12"
+    article.description.should eq "A wonderful thing"
+    article.quantity.should eq "2"
+  end
+
+  it "converts to hash and back without losing information" do
+    obj = Collector::ArticleListItem.new( article_list_item_hash )
+    hash = Collector::ArticleListItemRepresenter.new(obj).to_hash
+    obj2 = Collector::ArticleListItem.new
+    Collector::ArticleListItemRepresenter.new(obj2).from_hash(hash)
+    obj2.should eq obj
+  end
+
+end

data/spec/base_model_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+class Model < Collector::BaseModel
+  attributes :required1, :required2
+  attributes_opt :optional1, :optional2
+end
+
+class NestedModel < Collector::BaseModel
+  attribute :required
+  attribute_opt :optional
+end
+
+class TolerantModel < Collector::BaseModel
+  swallow_unsupported_attributes
+end
+
+describe Collector::BaseModel do
+  it "raises an error when initialized with undeclared attributes" do
+    expect{ Model.new(required1: true,
+                      required2: true,
+                      unsupported: true)}.to raise_error ArgumentError
+  end
+  it "does not raise an error for undeclared attributes if set to swallow those" do
+    expect{ TolerantModel.new(humbug: true) }.not_to raise_error
+  end
+  it "reports presence of required attributes" do
+    obj = Model.new(required1: true, required2: true)
+    obj.should have_required_attributes
+    obj.missing_attributes.should be_empty
+  end
+  it "reports absence of required attributes" do
+    obj = Model.new(required1: true, optional1: true, optional2: true)
+    obj.should_not have_required_attributes
+    obj.missing_attributes.should eq [:required2]
+  end
+  it "reports absence of required attributes in nested objects" do
+    nested = NestedModel.new(optional: true)
+    obj = Model.new(required1: true, required2: nested, optional1: nested)
+    obj.should_not have_required_attributes
+    obj.missing_attributes.should eq [{required2: [:required]}, {optional1: [:required]}]
+  end
+end

data/spec/helpers/sandbox_objects_helper.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+# Hashes
+def sandbox_user_address_hash
+  { address1: "GATUADRESSAKT211",
+    address2: "Not required",
+    city: "UMEÅ",
+    country_code: "SE",
+    postal_code: "90737",
+    first_name: "FÖRNAMNAKT211",
+    last_name: "EFTERNAMNAKT211" }
+end
+
+def sandbox_user_address
+  Collector::Address.new(sandbox_user_address_hash )
+end
+
+def sandbox_invoice_row_hash(opts = {})
+  { article_id: "12",
+    description: "A wonderful thing",
+    quantity: "2",
+    unit_price: "12.0",
+    vat: "2.0"
+  }.merge(opts)
+end
+
+def sandbox_invoice_row(opts = {})
+  Collector::InvoiceRow.new(sandbox_invoice_row_hash(opts))
+end
+
+def sandbox_invoice_request_hash
+  {  activation_option: 0,
+    country_code: "SE",
+    currency: "SEK",
+    delivery_address: sandbox_user_address,
+    invoice_address: sandbox_user_address,
+    invoice_delivery_method: 1,
+    invoice_rows: [sandbox_invoice_row],
+    invoice_type: 0,
+    order_date: DateTime.now,
+    reg_no: "1602079954",
+    store_id: "355" }
+end
+
+def sandbox_invoice_request
+  Collector::InvoiceRequest.new(sandbox_invoice_request_hash)
+end
+
+def full_address_hash
+  sandbox_user_address_hash.merge({
+        address2: "not required",
+        co_address: "not required",
+        cell_phone_number: "not required",
+        # company_name: "not required",   # Can't test. Sandbox user is a "private customer"
+        email: "not@required.se",
+        phone_number: "not required"
+      })
+end
+
+def full_sandbox_address
+  Collector::Address.new(full_address_hash)
+end
+
+def full_invoice_request_hash
+  sandbox_invoice_request_hash.merge({
+        correlation_id: "test corr id",
+        cost_center: "not required",
+        credit_time: 10,
+        customer_no: "not required",
+        delivery_address: full_sandbox_address,
+        gender: 0,
+        invoice_address: full_sandbox_address,
+        order_no: "not required",
+        # product_code: "",  # Can't test, defined by Collector, requires agreement
+        purchase_type: 0,
+        reference: "not required",
+        sales_person: "not required"
+      })
+end
+
+def full_sandbox_invoice_request
+  Collector::InvoiceRequest.new(full_invoice_request_hash)
+end

data/spec/invoice_request_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Collector::InvoiceRequest do
+  let (:invoice_req_hash) { sandbox_invoice_request_hash }
+
+  it "can be constructed from a hash" do
+    invoice_req = Collector::InvoiceRequest.new( invoice_req_hash )
+    invoice_req_hash.each do |key, val|
+      invoice_req.send(key).should eq val
+    end
+  end
+
+  it "compares objects" do
+    invoice_req1 = Collector::InvoiceRequest.new( invoice_req_hash )
+    invoice_req2 = Collector::InvoiceRequest.new( invoice_req_hash )
+    invoice_req1.should eq invoice_req2
+  end
+
+  it "converts to hash and back without losing information" do
+    obj = sandbox_invoice_request
+    hash = Collector::InvoiceRequestRepresenter.new(obj).to_hash
+    obj2 = Collector::InvoiceRequest.new
+    Collector::InvoiceRequestRepresenter.new(obj2).from_hash(hash)
+    obj2.should eq obj
+  end
+
+end

data/spec/invoice_response_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Collector::InvoiceResponse do
+  let (:raw_invoice_reponse_hash) {
+    {:add_invoice_response_v31=>{:available_reservation_amount=>"0",
+                                :correlation_id=>nil,
+                                :due_date=>nil,
+                                :invoice_no=>"125423",
+                                :invoice_status=>"1",
+                                :invoice_url=>nil,
+                                :lowest_amount_to_pay=>nil,
+                                :payment_reference=>nil,
+                                :total_amount=>nil,
+                                :@xmlns=>"http://schemas.ecommerce.collector.se/v30/InvoiceService"}
+    }
+  }
+  it "can be constructed from a hash" do
+    inv_resp = Collector::InvoiceResponse.new( raw_invoice_reponse_hash[:add_invoice_response_v31] )
+    inv_resp.available_reservation_amount.should eq "0"
+    inv_resp.correlation_id.should eq nil
+    inv_resp.due_date.should eq nil
+    inv_resp.invoice_no.should eq "125423"
+    inv_resp.invoice_status.should eq "1"
+    inv_resp.lowest_amount_to_pay.should eq nil
+    inv_resp.payment_reference.should eq nil
+    inv_resp.total_amount.should eq nil
+  end
+
+end

data/spec/invoice_row_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Collector::InvoiceRow do
+  let (:invoice_row_hash) {
+    { "article_id" => "123",
+      "description" => "A fine piece",
+      "quantity" => "23",
+      "unit_price" => "12.50",
+      "vat" => "3.40"
+    }
+  }
+  it "can be constructed from a hash" do
+    invoice_row = Collector::InvoiceRow.new( invoice_row_hash )
+    invoice_row.article_id.should eq "123"
+    invoice_row.description.should eq "A fine piece"
+    invoice_row.quantity.should eq "23"
+    invoice_row.unit_price.should eq "12.50"
+    invoice_row.vat.should eq "3.40"
+  end
+
+  it "converts to hash and back without losing information" do
+    obj = Collector::InvoiceRow.new( invoice_row_hash )
+    hash = Collector::InvoiceRowRepresenter.new(obj).to_hash
+    obj2 = Collector::InvoiceRow.new
+    Collector::InvoiceRowRepresenter.new(obj2).from_hash(hash)
+    obj2.should eq obj
+  end
+
+end

data/spec/operations/activate_invoice_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'vcr'
+
+describe "Collector::Client" do
+  # TODO: Should be a shared example, but hard to make it fit
+  def spec_correct_response(response)
+    response.should be_kind_of Collector::InvoiceResponse
+    response.payment_reference.should_not be_nil
+    # TODO: What does this depend on?
+    response.lowest_amount_to_pay.should eq "50.00"
+    expected_due_date = (Time.now + 180*24*60*60).to_f
+    response.due_date.to_time.to_f.should be_within(24*60*60).of(expected_due_date)
+    response.invoice_url.should match %r(https://commerce.collector.se/testportal/PdfInvoice\?pnr=(\d+)\&invnr=#{@invoice_no})
+  end
+
+  before :each do
+    @client = collector_client
+  end
+
+  context "#activate_invoice" do
+
+    it "performs an ActivateInvoice request" do
+      VCR.use_cassette('activate_invoice') do
+        @invoice_no = add_original_invoice
+        response = @client.activate_invoice(invoice_no: @invoice_no,
+                                            store_id: "355",
+                                            country_code: "SE",
+                                            correlation_id: "testing_activate_invoice")
+        spec_correct_response(response)
+        response.correlation_id.should eq "testing_activate_invoice"
+        total_price = [product1, product2, product3].reduce(0){|memo, p| memo += (p.unit_price * p.quantity) }
+        response.total_amount.to_f.should eq total_price
+      end
+    end
+  end # #activate_invoice
+  context "#part_activate_invoice" do
+    def part_activate
+      @product = product2
+      @item = Collector::ArticleListItem.new(@product)
+      @response = @client.part_activate_invoice(
+                      invoice_no: @invoice_no,
+                        store_id: "355",
+                    country_code: "SE",
+                  correlation_id: "testing_part_activate_invoice",
+                    article_list: [@item])
+    end
+    it "requires the article_list parameter" do
+      VCR.use_cassette('part_activate_invoice', :record => :new_episodes) { @invoice_no = add_original_invoice }
+      expect {
+          @client.part_activate_invoice(invoice_no: @invoice_no, store_id: "355", country_code: "SE")
+        }.to raise_error ArgumentError
+    end
+    it "performs a PartActivateInvoice request" do
+      VCR.use_cassette('part_activate_invoice', :record => :new_episodes) do
+        @invoice_no = add_original_invoice
+        part_activate
+        spec_correct_response(@response)
+        @response.correlation_id.should eq "testing_part_activate_invoice"
+        @response.total_amount.to_f.should eq (@product.unit_price * @item.quantity)
+      end
+    end
+    it "returns the new invoice number" do
+      VCR.use_cassette('part_activate_invoice', :record => :new_episodes) do
+        @invoice_no = add_original_invoice
+        part_activate
+        @response.new_invoice_no.should_not be_nil
+      end
+      VCR.use_cassette('activate_remainder_invoice') do
+        @invoice_no = @response.new_invoice_no
+        new_resp = @client.activate_invoice(invoice_no: @invoice_no,
+                                              store_id: "355",
+                                          country_code: "SE",
+                                        correlation_id: "testing_remainder_activate_invoice")
+        spec_correct_response(new_resp)
+        new_resp.correlation_id.should eq "testing_remainder_activate_invoice"
+        total_price = [product1, product2, product3].reduce(0){|memo, p| memo += (p.unit_price * p.quantity) }
+        activated_amount = @product.unit_price * @item.quantity
+        new_resp.total_amount.to_f.should eq total_price - activated_amount
+      end
+    end
+  end # #part_activate_invoice
+end