active_zuora 1.3.0 → 2.6.0

data/lib/active_zuora/scoping.rb

@@ -0,0 +1,50 @@
+module ActiveZuora
+  module Scoping
+
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+
+        # Delegate to :scoped
+        delegate :find, :all, :find_each, :to => :scoped
+        delegate :select, :where, :and, :or, :order, :to => :scoped
+        delegate :first, :last, :each, :map, :any?, :empty?, :blank?, :present?, :size, :count, :to => :scoped
+
+        # Keep track of a current scope.
+        attr_accessor :current_scope
+
+      end
+    end
+
+    module ClassMethods
+
+      def scoped
+        current_scope || relation
+      end
+
+      def unscoped
+        block_given? ? relation.scoped { yield } : relation
+      end
+
+      def exclude_from_queries(*field_names)
+        (@excluded_from_queries ||= []).concat field_names.map(&:to_sym)
+      end
+
+      def relation
+        query_field_names = field_names - (@excluded_from_queries ||= [])
+        Relation.new(self, query_field_names)
+      end
+
+      def scope(name, body)
+        # Body can be a Relation or a lambda that returns a relation.
+        define_singleton_method(name) do |*args|
+          body.respond_to?(:call) ? body.call(*args) : scoped.merge(body)
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/active_zuora/subscribe.rb

@@ -0,0 +1,42 @@
+module ActiveZuora
+  module Subscribe
+
+    # This is meant to be included onto a SubscribeRequest class.
+    # Returns true/false on success.
+    # Result hash is stored in #result.
+    # If success, the subscription id and account id will be set in those objects.
+    # If failure, errors will be present on object.
+
+    extend ActiveSupport::Concern
+
+    included do
+      include Base
+      attr_accessor :result
+    end
+
+    def subscribe
+      self.result = self.class.connection.request(:subscribe) do |soap|
+        soap.body do |xml| 
+          build_xml(xml, soap, 
+            :namespace => soap.namespace,
+            :element_name => :subscribes,
+            :force_type => true)
+        end
+      end[:subscribe_response][:result]
+      if result[:success]
+        account.id = result[:account_id]
+        subscription_data.subscription.id = result[:subscription_id]
+        clear_changed_attributes
+        true
+      else
+        add_zuora_errors(result[:errors])
+        false
+      end
+    end
+
+    def subscribe!
+      raise "Could not subscribe: #{errors.full_messages.join ', '}" unless subscribe
+    end
+
+  end
+end

data/lib/active_zuora/version.rb

@@ -0,0 +1,3 @@
+module ActiveZuora
+  VERSION = "2.6.0"
+end

data/lib/active_zuora/z_object.rb

@@ -0,0 +1,21 @@
+module ActiveZuora
+  module ZObject
+    
+    extend ActiveSupport::Concern
+
+    included do
+      include Base
+      include Scoping
+      include HasManyAssociations
+      include Persistence
+      field :id, :string
+    end
+ 
+    def ==(another_zobject)
+      another_zobject.is_a?(ZObject) &&
+        zuora_object_name == another_zobject.zuora_object_name && 
+        id == another_zobject.id
+    end
+
+  end
+end

data/spec/account_integration_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe 'Create Account' do
+
+  integration_test do
+
+    let(:account) do
+      Z::Account.new name: 'Joe Customer',
+                     currency: Tenant.currency,
+                     bill_cycle_day: '1'
+    end
+
+    after(:each) do
+      account.delete unless account.new_record?
+    end
+
+    it 'can create an account' do
+      expect(account).to be_a_new_record
+      expect(account).to_not be_valid
+      expect(account.id).to_not be_present
+      expect(account.errors.full_messages).to eq ["Status can't be blank"]
+
+      now 'update account to be valid' do
+        account.status = 'Draft'
+        expect(account).to be_valid
+        expect(account.errors.full_messages).to be_empty
+      end
+
+      now 'save the account' do
+        expect(account.save).to be true
+        expect(account.id).to be_present
+        expect(account.errors.full_messages).to eq []
+      end
+
+      now 'ensure error messages are accessible' do
+        expect(account.update_attributes status: 'Active').to be false
+        expect(account.errors.full_messages).to eq ['Active account must have both sold to and bill to.']
+      end
+    end
+  end
+end

data/spec/base_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe ActiveZuora::Base do
+  class Comment
+    include ActiveZuora::ZObject
+    field :name, :string
+    field :null_field, :string
+  end
+
+  context "#fields_order" do
+    let(:comment) { Comment.new :id => 'blog1', :null_field => nil, :name => 'test' }
+    let(:field_id) { comment.get_field(:id) }
+    let(:field_null) { comment.get_field(:null_field) }
+    let(:field_name) { comment.get_field(:name) }
+    let(:sorted_fields) { [field_null, field_id, field_name] }
+
+    it 'When the value of a field is null, it should be the first' do
+      fields1 = [field_id, field_null]
+      expect(fields1.sort(&comment.method(:fields_order))).to eq([field_null, field_id])
+
+      fields2 = [field_name, field_null]
+      expect(fields2.sort(&comment.method(:fields_order))).to eq([field_null, field_name])
+
+      fields3 = [field_id, field_name, field_null]
+      expect(fields3.sort(&comment.method(:fields_order))).to eq(sorted_fields)
+    end
+
+    it 'When the field name is id, it should be after the nil value fields but before all other fields' do
+      fields1 = [field_name, field_id]
+      expect(fields1.sort(&comment.method(:fields_order))).to eq([field_id, field_name])
+
+      fields2 = [field_null, field_id]
+      expect(fields2.sort(&comment.method(:fields_order))).to eq([field_null, field_id])
+
+      fields3 = [field_name, field_id, field_null]
+      expect(fields3.sort(&comment.method(:fields_order))).to eq(sorted_fields)
+    end
+  end
+end

data/spec/belongs_to_associations_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "BelongsToAssociations" do
+
+  class Blog
+    include ActiveZuora::ZObject
+  end
+
+  class Comment
+    include ActiveZuora::Base
+    belongs_to :blog
+  end
+
+  it "should define a attribute assignment method method for the object" do
+    blog = Blog.new :id => "blog1"
+    comment = Comment.new :blog => blog
+    expect(comment.blog_loaded?).to be_truthy
+    expect(comment.blog).to eq(blog)
+    expect(comment.blog_id).to eq(blog.id)
+    comment.blog = nil
+    expect(comment.blog_loaded?).to be_truthy
+    expect(comment.blog).to be_nil
+    expect(comment.blog_id).to be_nil
+  end
+
+  it "should define a attribute assignment method for the object id" do
+    blog = Blog.new :id => "blog1"
+    comment = Comment.new :blog => blog
+    expect(comment.blog_loaded?).to be_truthy
+    comment.blog_id = "blog2"
+    expect(comment.blog_loaded?).to be_falsey
+  end
+
+end
+

data/spec/collection_proxy_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe "ActiveZuora::CollectionProxy" do
+
+  it "should initialize" do
+    cp = Z::CollectionProxy.new
+    expect(cp).to be_empty
+    cp = Z::CollectionProxy.new([Z::SubscribeRequest.new])
+    expect(cp).not_to be_empty
+  end
+
+  it "should respond to enumerable methods" do
+    cp = Z::CollectionProxy.new([Z::SubscribeRequest.new])
+    cp.each do |cp|
+      expect(cp)
+    end
+    cp.inject do |memo,cp|
+      expect(memo)
+      expect(cp)
+    end
+  end
+
+  it "should respond to the batch_subscribe method" do
+    cp = Z::CollectionProxy.new([Z::SubscribeRequest.new])
+    expect(cp.respond_to?(:batch_subscribe)).to eq(true)
+  end
+
+end

data/spec/connection_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe ActiveZuora::Connection do
+  context "custom header" do
+    before do
+      @connection = ActiveZuora::Connection.new
+      @stub_was_called = false
+    end
+
+    it "passes the regular header if not set" do
+      allow(Savon::SOAP::Request).to receive(:new) do |config, http, soap|
+        @stub_was_called = true
+        expect(soap.header).to eq( { "SessionHeader" => {"session" => nil} } )
+
+        double('response').as_null_object
+      end
+
+      @connection.request(:amend) {}
+
+      expect(@stub_was_called).to be_truthy
+    end
+
+    it "merges in a custom header if set" do
+      @connection.custom_header = {'CallOptions' => {'useSingleTransaction' => true}}
+      allow(Savon::SOAP::Request).to receive(:new) do |config, http, soap|
+        @stub_was_called = true
+        expect(soap.header).to eq( { "SessionHeader" => {"session" => nil}, 'CallOptions' => {'useSingleTransaction' => true} } )
+
+        double('response').as_null_object
+      end
+
+      @connection.request(:amend) {}
+
+      expect(@stub_was_called).to be_truthy
+    end
+  end
+
+  describe 'login' do
+    before do
+      @connection = described_class.new
+    end
+
+    context 'when a custom header is set' do
+      it 'uses the custom header' do
+        @connection.custom_header = { 'TestHeader' => 'Foo' }
+        allow(Savon::SOAP::Request).to receive(:new) do |config, http, soap|
+          expect(soap.header).to eq({ 'TestHeader' => 'Foo' })
+          double('response').as_null_object
+        end
+
+        @connection.login
+      end
+    end
+
+    context 'when a custom header is not set' do
+      it 'does not use the custom header' do
+        allow(Savon::SOAP::Request).to receive(:new) do |config, http, soap|
+          expect(soap.header).to eq({})
+          double('response').as_null_object
+        end
+
+        @connection.login
+      end
+    end
+  end
+end

data/spec/fields/date_field_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe ActiveZuora::DateField do
+  subject { described_class.new("date", described_class, {:zuora_name => "date"}) }
+
+  describe "#type_cast" do
+    it "returns nil if provided nil" do
+      expect(subject.type_cast(nil)).to eq(nil)
+    end
+
+    it "returns a date when given a datetime object" do
+      datetime = DateTime.now
+      expect(subject.type_cast(datetime)).to be_a(Date)
+    end
+
+    it "returns a date when given a date object" do
+      date = Date.today
+      expect(subject.type_cast(date)).to be_a(Date)
+    end
+  end
+
+  describe "#build_xml" do
+    let(:xml)  { double(:xml, :tag! => nil) }
+    let(:soap) { double(:soap, :namespace_by_uri => nil) }
+    let(:options) { {} }
+
+    it "handles a nil value" do
+      expect { subject.build_xml(xml, soap, nil, options) }.to_not raise_error
+    end
+
+    it "handles a date value" do
+      expect { subject.build_xml(xml, soap, Date.today, options) }.to_not raise_error
+    end
+  end
+end

data/spec/has_many_integration_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe "HasManyRelations" do
+
+  integration_test do
+
+    before :all do
+      @account = Z::Account.create!(
+        :name => "ZObject Integration Test Account",
+        :status => "Draft",
+        :currency => Tenant.currency,
+        :bill_cycle_day => 1)
+      @billy = Z::Contact.create!(
+        :account => @account,
+        :first_name => "Billy",
+        :last_name => "Blanks")
+      @franky = Z::Contact.create!(
+        :account => @account,
+        :first_name => "Franky",
+        :last_name => "Funhouse")
+    end
+
+    after :all do
+      # Delete the account to cleanup in case a test failed.
+      @account.delete if @account
+    end
+
+    it "can specify conditions and order" do
+      Z::Account.instance_eval do
+        has_many :billies, :conditions => { :first_name => "Billy" }, :order => [:first_name, :desc], :class_name => 'Z::Contact'
+      end
+			expect(@account.billies.to_a).to eq([@billy])
+      expect(@account.billies.scope.order_attribute).to eq(:first_name)
+      expect(@account.billies.scope.order_direction).to eq(:desc)
+    end
+
+    it "can behave like an array" do
+      expect(@account.contacts.size).to eq(2)
+      expect(@account.contacts.map(&:first_name)).to match_array(%w{Billy Franky})
+    end
+
+    it "can respond to functions on the Relation" do
+      @account.contacts.unload
+      expect(@account.contacts.loaded?).to be_falsey
+      @account.contacts.reload
+      expect(@account.contacts.loaded?).to be_truthy
+      expect(@account.contacts.where(:last_name => "Funhouse").to_a).to eq([@franky])
+      expect(@account.contacts.loaded?).to be_truthy
+      expect(@account.contacts.to_a).to match_array([@billy, @franky])
+    end
+
+  end
+end

data/spec/lazy_attr_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'LazyAttr' do
+  class TestInovice
+    include ActiveZuora::LazyAttr
+    lazy_load :test_body
+  end
+
+  subject { TestInovice.new }
+
+  it "should fetch a lazy loaded attribute from the api" do
+    expect(subject).to receive(:fetch_field).with(:test_body){ 'Jesse "The Body"' }
+    subject.test_body
+  end
+
+  it "should should not refetch an attribute after it's been loaded once" do
+    expect(subject).to receive(:fetch_field).with(:test_body).once { 'Jesse "The Body"' }
+    subject.test_body
+    subject.test_body
+  end
+
+end