kaui 0.1.0 → 0.1.2

data/test/functional/kaui/bundles_controller_test.rb

@@ -1,9 +1,21 @@
 require 'test_helper'
 
-module Kaui
-  class BundlesControllerTest < ActionController::TestCase
-    # test "the truth" do
-    #   assert true
-    # end
+class Kaui::BundlesControllerTest < ActionController::TestCase
+  fixtures :accounts, :bundles
+
+  test "should get index" do
+    get :index
+    assert_response :success
+  end
+
+  test "should find bundle by id" do
+    pierre = accounts(:pierre)
+    bundle = bundles(:bundle_for_pierre)
+
+    get :show, :id => bundle["bundleId"]
+    assert_response :success
+    assert_equal assigns(:account).account_id, pierre["accountId"]
+    assert_equal assigns(:bundle).bundle_id, bundle["bundleId"]
+    assert_equal assigns(:bundle).account_id, pierre["accountId"]
   end
-end
+end

data/test/functional/kaui/invoice_items_controller_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class Kaui::InvoiceItemsControllerTest < ActionController::TestCase
+  fixtures :invoice_items
+
+  test "should get index" do
+    get :index
+    assert_response :success
+  end
+
+  test "should find invoice item by id" do
+    item = invoice_items(:recurring_item_for_pierre)
+
+    get :show, :id => item["invoiceItemId"], :invoice_id => item["invoiceId"]
+    assert_response :success
+    assert_equal assigns(:invoice_item).invoice_item_id, item["invoiceItemId"]
+  end
+end

data/test/functional/kaui/invoices_controller_test.rb

@@ -1,9 +1,21 @@
 require 'test_helper'
 
-module Kaui
-  class InvoicesControllerTest < ActionController::TestCase
-    # test "the truth" do
-    #   assert true
-    # end
+class Kaui::InvoicesControllerTest < ActionController::TestCase
+  fixtures :accounts, :invoices
+
+  test "should get index" do
+    get :index
+    assert_response :success
+  end
+
+  test "should find invoice by id" do
+    pierre = accounts(:pierre)
+    invoice = invoices(:invoice_for_pierre)
+
+    get :show, :id => invoice["invoiceId"]
+    assert_response :success
+    assert_equal assigns(:account).account_id, pierre["accountId"]
+    assert_equal assigns(:invoice).invoice_id, invoice["invoiceId"]
+    assert_equal assigns(:invoice).account_id, pierre["accountId"]
   end
-end
+end

data/test/functional/kaui/tag_definitions_controller_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+module Kaui
+  class TagDefinitionsControllerTest < ActionController::TestCase
+    fixtures :tag_definitions
+
+    setup do
+      @tag_definition = TagDefinition.new(tag_definitions(:payment_plan))
+      @routes = Kaui::Engine.routes
+    end
+
+    test "should get index" do
+      get :index
+      assert_response :success
+      assert_not_nil assigns(:tag_definitions)
+    end
+
+    test "should get new" do
+      get :new
+      assert_response :success
+    end
+
+    test "should create tag_definition" do
+      assert_difference('TagDefinition.count') do
+        post :create, tag_definition: { description: @tag_definition.description, name: @tag_definition.name }
+      end
+
+      # TODO - for now, we redirect to the main page as we don't get the id back
+      assert_redirected_to tag_definitions_path
+      # assert_redirected_to tag_definition_path(assigns(:tag_definition))
+    end
+
+    test "should show tag_definition" do
+      get :show, id: @tag_definition
+      assert_response :success
+    end
+
+    test "should get edit" do
+      get :edit, id: @tag_definition
+      assert_response :success
+    end
+
+    # TODO - not supported yet
+    # test "should update tag_definition" do
+    #   put :update, id: @tag_definition, tag_definition: { description: @tag_definition.description, id: @tag_definition.id, name: @tag_definition.name }
+    #   assert_redirected_to tag_definition_path(assigns(:tag_definition))
+    # end
+
+    test "should destroy tag_definition" do
+      post :create, tag_definition: { description: @tag_definition.description, name: @tag_definition.name }
+      new_id = assigns(:tag_definition).id
+
+      assert_difference('TagDefinition.count', -1) do
+        delete :destroy, id: new_id
+      end
+
+      assert_redirected_to tag_definitions_path
+    end
+  end
+end

data/test/test_helper.rb

@@ -3,8 +3,151 @@ ENV["RAILS_ENV"] = "test"
 
 require File.expand_path("../dummy/config/environment.rb",  __FILE__)
 require "rails/test_help"
+require 'securerandom'
 
 Rails.backtrace_cleaner.remove_silencers!
 
 # Load support files
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+# Mock killbill-server and serve data from the fixtures
+module Kaui::KillbillHelper
+  @@fixtures ||= {}
+
+  def self.get_account(account_id, with_account_id=false)
+    find_among_fixtures(Kaui::Account, account_id)
+  end
+  
+  def self.get_account_by_external_key(account_id, with_account_id=false)
+    find_among_fixtures(Kaui::Account, account_id)
+  end
+
+  def self.get_invoice(invoice_id)
+    find_among_fixtures(Kaui::Invoice, invoice_id)
+  end
+
+  def self.get_invoice_item(invoice_id, invoice_item_id)
+    find_among_fixtures(Kaui::InvoiceItem, invoice_item_id)
+  end
+
+  def self.get_bundle(bundle_id)
+    find_among_fixtures(Kaui::Bundle, bundle_id)
+  end
+
+  def self.get_payments(invoice_id)
+    []
+  end
+
+  def self.get_payment_methods(account_id)
+    []
+  end
+
+  def self.get_bundles(account_id)
+    []
+  end
+
+  def self.get_subscriptions_for_bundle(bundle_id)
+    []
+  end
+
+  def self.get_tags_for_account(account_id)
+    []
+  end
+
+  def self.get_tag_definitions
+    find_all_among_fixtures(Kaui::TagDefinition)
+  end
+
+  def self.get_tag_definition(tag_definition_id)
+    find_among_fixtures(Kaui::TagDefinition, tag_definition_id, 'id')
+  end
+
+  def self.create_tag_definition(tag_definition)
+    tag_definition.id = SecureRandom.uuid
+    add_fixture(tag_definition, Kaui::TagDefinition)
+  end
+
+  def self.delete_tag_definition(tag_definition_id)
+    delete_fixture(Kaui::TagDefinition, tag_definition_id, 'id')
+  end
+
+  def self.find_among_fixtures(clazz, id, type_id=nil)
+    results = find_all_among_fixtures(clazz, id, type_id)
+    results.length > 0 ? results[0] : nil
+  end
+
+  def self.find_all_among_fixtures(clazz, id=nil, type_id=nil)
+    results = []
+    type = clazz.name.demodulize.underscore
+    type_id = "#{clazz.name.demodulize.camelize}Id".uncapitalize unless type_id
+    @@fixtures.each do |k,v|
+      next unless k == "#{type}s"
+      v.each do |w,u|
+        results << clazz.new(u.fixture) if u.fixture[type_id] == id or !id.present?
+      end
+    end
+
+    return results
+  end
+
+  def self.add_fixture(fixture, clazz)
+    type = clazz.name.demodulize.underscore
+    @@fixtures["#{type}s"].fixtures ||= {}
+    @@fixtures["#{type}s"].fixtures["auto_generated_fixture_#{rand(100)}"] = ActiveRecord::Fixture.new(fixture.to_hash, clazz)
+    fixture
+  end
+
+  def self.delete_fixture(clazz, id, type_id=nil)
+    type = clazz.name.demodulize.underscore
+    type_id = "#{clazz.name.demodulize.camelize}Id".uncapitalize unless type_id
+    @@fixtures.each do |k,v|
+      next unless k == "#{type}s"
+      v.each do |w,u|
+        v.fixtures.delete(w) if u.fixture[type_id] == id
+      end
+    end
+  end
+
+  def self.set_fixtures(f)
+    @@fixtures = f
+  end
+end
+
+class ActiveRecord::Fixtures
+  # Monkey-patch the create_fixtures method not to rely on a database
+  def self.create_fixtures(fixtures_directory, table_names, class_names = {})
+    table_names = [table_names].flatten.map { |n| n.to_s }
+    table_names.each { |n|
+      class_names[n.tr('/', '_').to_sym] = n.classify if n.include?('/')
+    }
+
+    unless table_names.empty?
+      fixtures_map = {}
+      table_names.map do |path|
+        table_name = path.tr '/', '_'
+        fixtures_map[path] = ActiveRecord::Fixtures.new(nil,
+                                                        table_name,
+                                                        class_names[table_name.to_sym] || table_name.classify,
+                                                        ::File.join(fixtures_directory, path))
+      end
+
+      all_loaded_fixtures.update(fixtures_map)
+      cache_fixtures(nil, fixtures_map)
+
+      Kaui::KillbillHelper.set_fixtures fixtures_map
+    end
+    cached_fixtures(nil, table_names)
+  end
+end
+
+class ActiveRecord::Fixture
+  def find
+    @fixture
+  end
+end
+
+class String
+  def uncapitalize
+    self[0, 1].downcase + self[1..-1]
+  end
+end

data/test/unit/helpers/kaui/plugin_infos_helper_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+module Kaui::PluginInfosHelperTest
+  @@plugin_info_keys = [:accountId, :type, :cardHolderName, :cardType, :expirationDate, :maskNumber,
+                        :address1, :address2, :city, :postalCode, :state, :country]
+
+  def plugin_info_properies
+    properties = []
+    @@plugin_info_keys.each do |key|
+      as_json = plugin_info_properties("plugin_info_property_#{key.to_s}".to_sym)
+      properties << Kaui::PluginInfoProperty.new(as_json).to_hash
+    end
+    properties
+  end
+
+  def create_plugin_info(plugin_info_json)
+    plugin_info_json["properties"] = plugin_info_properies
+    Kaui::PluginInfo.new(plugin_info_json)
+  end
+end

data/test/unit/kaui/account_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class Kaui::AccountTest < ActiveSupport::TestCase
+  fixtures :accounts
+
+  test "can serialize from json" do
+    as_json = accounts(:pierre)
+    pierre = Kaui::Account.new(as_json)
+
+    assert_equal as_json["accountId"], pierre.account_id
+    assert_equal as_json["address1"], pierre.address1
+    assert_equal as_json["address2"], pierre.address2
+    assert_equal as_json["company"], pierre.company
+    assert_equal as_json["country"], pierre.country
+    assert_equal as_json["currency"], pierre.currency
+    assert_equal as_json["email"], pierre.email
+    assert_equal as_json["externalKey"], pierre.external_key
+    assert_equal as_json["name"], pierre.name
+    assert_equal as_json["paymentMethodId"], pierre.payment_method_id
+    assert_equal as_json["phone"], pierre.phone
+    assert_equal as_json["state"], pierre.state
+    assert_equal as_json["timeZone"], pierre.timezone
+  end
+  
+  test "can read correct positive balance" do
+    as_json = accounts(:account_with_positive_balance)
+    t = Kaui::Account.new(as_json)
+    assert(t.balance > 0)
+  end
+
+  test "can read correct negative balance" do
+    as_json = accounts(:account_with_negative_balance)
+    t = Kaui::Account.new(as_json)
+    assert(t.balance < 0)
+  end
+
+  test "can read correct zero balance" do
+    as_json = accounts(:account_with_zero_balance)
+    t = Kaui::Account.new(as_json)
+    assert(t.balance == 0)
+  end
+end

data/test/unit/kaui/base_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+class Kaui::BaseTest < ActiveSupport::TestCase
+
+  class Kaui::SomeKlass < Kaui::Base
+    define_attr :attribute_id
+
+    has_many :klasses, Kaui::SomeKlass
+  end
+
+  test "has_many association should return [] by default" do
+    klass = Kaui::SomeKlass.new
+    assert_equal [], klass.klasses
+  end
+
+  test "can serialize from hash" do
+    klass = Kaui::SomeKlass.new(:attribute_id => 12)
+    assert_equal 12, klass.attribute_id
+  end
+
+  test "can serialize from json" do
+    klass = Kaui::SomeKlass.new(:attributeId => 12)
+    assert_equal 12, klass.attribute_id
+  end
+
+  test "convert camelcase hash into snake case hash" do
+    # Happy path
+    new_hash = Kaui::Base.convert_hash_keys({:accountId=>12, :data_id=>14})
+    assert_equal 12, new_hash[:account_id]
+    assert_equal 14, new_hash[:data_id]
+    assert_nil new_hash[:accountId]
+
+    # Edge cases
+    assert_nil Kaui::Base.convert_hash_keys(nil)
+    assert_equal [], Kaui::Base.convert_hash_keys([])
+    assert_equal Hash.new, Kaui::Base.convert_hash_keys({})
+    assert_equal 1, Kaui::Base.convert_hash_keys(1)
+  end
+end

data/test/unit/kaui/date_helper_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class Kaui::DateHelperTest < ActiveSupport::TestCase
+  include Kaui::DateHelper
+
+  test "can parse from string" do
+    assert_equal "2012-07-01", format_date("2012-07-01T12:55:44Z")
+  end
+
+  test "can parse from date" do
+    assert_equal "2012-06-30", format_date(Date.new(2012, 7, 1))
+  end
+end

data/test/unit/kaui/invoice_item_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class Kaui::InvoiceItemTest < ActiveSupport::TestCase
+  fixtures :invoice_items
+
+  test "can serialize from json" do
+    as_json = invoice_items(:recurring_item_for_pierre)
+    invoice = Kaui::InvoiceItem.new(as_json)
+
+    assert_equal as_json["invoiceItemId"], invoice.invoice_item_id
+    assert_equal as_json["invoiceId"], invoice.invoice_id
+    assert_equal as_json["accountId"], invoice.account_id
+    assert_equal as_json["bundleId"], invoice.bundle_id
+    assert_equal as_json["subscriptionId"], invoice.subscription_id
+    assert_equal as_json["planName"], invoice.plan_name
+    assert_equal as_json["phaseName"], invoice.phase_name
+    assert_equal as_json["description"], invoice.description
+    assert_equal as_json["startDate"], invoice.start_date
+    assert_equal as_json["endDate"], invoice.end_date
+    assert_equal as_json["amount"], invoice.amount
+    assert_equal as_json["currency"], invoice.currency
+  end
+end

data/test/unit/kaui/invoice_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class Kaui::InvoiceTest < ActiveSupport::TestCase
+  fixtures :invoices
+
+  test "can serialize from json" do
+    as_json = invoices(:invoice_for_pierre)
+    invoice = Kaui::Invoice.new(as_json)
+    
+    assert_equal as_json["amount"], invoice.amount
+    assert_equal as_json["cba"], invoice.credit_balance_adjustment
+    assert_equal as_json["creditAdj"], invoice.credit_adjustment
+    assert_equal as_json["refundAdj"], invoice.refund_adjustment
+    assert_equal as_json["invoiceId"], invoice.invoice_id
+    assert_equal as_json["invoiceDate"], invoice.invoice_date
+    assert_equal as_json["targetDate"], invoice.target_date
+    assert_equal as_json["invoiceNumber"], invoice.invoice_number
+    assert_equal as_json["accountId"], invoice.account_id
+  end
+end