killbill 1.0.0

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+build
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+.jbundler
+Jarfile.lock
+Gemfile.lock
+*.swp

data/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+
+notifications:
+  email:
+    - killbilling-dev@googlegroups.com
+
+rvm:
+  - jruby-18mode
+  - jruby-19mode
+  - jruby-head
+
+jdk:
+  - openjdk7
+  - oraclejdk7
+  - openjdk6
+
+matrix:
+  allow_failures:
+    - rvm: jruby-head

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Jarfile

@@ -0,0 +1,2 @@
+jar 'com.ning.billing:killbill-api', '0.1.48'
+jar 'com.ning.billing:killbill-util:tests', '0.1.48'

data/README.md

@@ -0,0 +1,116 @@
+killbill-plugin-framework-ruby
+==============================
+
+Framework to write Killbill plugins in Ruby.
+
+There are various types of plugins one can write for Killbill:
+
+1. notifications plugins, which listen to external bus events and can react to it
+2. payment plugins, which are used to issue payments against a payment gateway
+
+How to write a Notification plugin
+----------------------------------
+
+    require 'killbill'
+
+    class MyNotificationPlugin < Killbill::Plugin::Notification
+      # Overriding this method is optional, only if you need to do some initialization work
+      def start_plugin
+        puts "MyNotificationPlugin plugin starting"
+        super
+        puts "MyNotificationPlugin plugin started"
+      end
+
+      # Invoked each time an event is received
+      def on_event(event)
+        puts "Received Killbill event #{event}"
+      end
+
+      # Overriding this method is optional, only if you need to do some tear down work
+      def stop_plugin
+        puts "MyNotificationPlugin plugin stopping"
+        super
+        puts "MyNotificationPlugin plugin stopped"
+      end
+    end
+
+Make sure to create the corresponding killbill.properties file:
+
+    mainClass=MyNotificationPlugin
+    pluginType=NOTIFICATION
+
+How to write a Payment plugin
+-----------------------------
+
+    require 'killbill'
+
+    class MyPaymentPlugin < Killbill::Plugin::Payment
+      def start_plugin
+        puts "MyPaymentPlugin plugin starting"
+        super
+        puts "MyPaymentPlugin plugin started"
+      end
+
+      def charge(killbill_account_id, killbill_payment_id, amount_in_cents, options = {})
+      end
+
+      def refund(killbill_account_id, killbill_payment_id, amount_in_cents, options = {})
+      end
+
+      def get_payment_info(killbill_payment_id, options = {})
+      end
+
+      def add_payment_method(payment_method, options = {})
+      end
+
+      def delete_payment_method(external_payment_method_id, options = {})
+      end
+
+      def update_payment_method(payment_method, options = {})
+      end
+
+      def set_default_payment_method(payment_method, options = {})
+      end
+
+      def create_account(killbill_account, options = {})
+      end
+
+      # Overriding this method is optional, only if you need to do some tear down work
+      def stop_plugin
+        puts "MyPaymentPlugin plugin stopping"
+        super
+        puts "MyPaymentPlugin plugin stopped"
+      end
+    end
+
+Make sure to create the corresponding killbill.properties file:
+
+    mainClass=MyPaymentPlugin
+    pluginType=PAYMENT
+
+Rake tasks
+----------
+
+The killbill gem also ships helpful Rake tasks to package Killbill-ready plugins.
+
+To access these tasks, add the following to your Rakefile:
+
+    # Install tasks to package the plugin for Killbill
+    require 'killbill/rake_task'
+    Killbill::PluginHelper.install_tasks
+
+    # (Optional) Install tasks to build and release your plugin gem
+    require 'bundler/setup'
+    Bundler::GemHelper.install_tasks
+
+You can verify these tasks are available by running `rake -T`.
+
+To build the artifacts into pkg/:
+
+    # Cleanup output directories
+    rake killbill:clean
+    # Build your plugin gem in the pkg/ directory
+    rake build
+    # Build the Killbill plugin in the pkg/ directory
+    # The <plugin_name>-<plugin-version>/ directory is used as a staging directory
+    rake killbill:package

data/Rakefile

@@ -0,0 +1,13 @@
+#!/usr/bin/env rake
+
+# Install tasks to build and release the plugin
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
+
+# Install test tasks
+require 'rspec/core/rake_task'
+desc "Run RSpec"
+RSpec::Core::RakeTask.new
+
+# Run tests by default
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/killbill.gemspec

@@ -0,0 +1,32 @@
+version = File.read(File.expand_path('../VERSION', __FILE__)).strip
+
+Gem::Specification.new do |s|
+  s.name        = 'killbill'
+  s.version     = version
+  s.summary     = 'Framework to write Killbill plugins in Ruby.'
+  s.description = 'Base classes to write plugins.'
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.license = 'Apache License (2.0)'
+
+  s.author   = 'Killbill core team'
+  s.email    = 'killbilling-users@googlegroups.com'
+  s.homepage = 'http://www.killbilling.org'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.bindir        = 'bin'
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.rdoc_options << '--exclude' << '.'
+
+  s.add_development_dependency 'jbundler', '~> 0.4.1'
+  s.add_development_dependency 'rake', '>= 0.8.7'
+  s.add_development_dependency 'rspec', '~> 2.12.0'
+
+  s.requirements << "jar 'com.ning.billing:killbill-api', '0.1.48'"
+  # For testing only
+  s.requirements << "jar 'com.ning.billing:killbill-util:tests', '0.1.48'"
+end

data/lib/killbill.rb

@@ -0,0 +1,46 @@
+begin
+  require 'java'
+rescue LoadError => e
+  warn 'You need JRuby to run Killbill plugins'
+  raise e
+end
+
+KILLBILL_APIS = %w(
+  com.ning.billing.account.api.AccountUserApi
+  com.ning.billing.analytics.api.sanity.AnalyticsSanityApi
+  com.ning.billing.analytics.api.user.AnalyticsUserApi
+  com.ning.billing.catalog.api.CatalogUserApi
+  com.ning.billing.entitlement.api.migration.EntitlementMigrationApi
+  com.ning.billing.entitlement.api.timeline.EntitlementTimelineApi
+  com.ning.billing.entitlement.api.transfer.EntitlementTransferApi
+  com.ning.billing.entitlement.api.user.EntitlementUserApi
+  com.ning.billing.invoice.api.InvoiceMigrationApi
+  com.ning.billing.invoice.api.InvoicePaymentApi
+  com.ning.billing.invoice.api.InvoiceUserApi
+  com.ning.billing.meter.api.MeterUserApi
+  com.ning.billing.overdue.OverdueUserApi
+  com.ning.billing.payment.api.PaymentApi
+  com.ning.billing.tenant.api.TenantUserApi
+  com.ning.billing.usage.api.UsageUserApi
+  com.ning.billing.util.api.AuditUserApi
+  com.ning.billing.util.api.CustomFieldUserApi
+  com.ning.billing.util.api.ExportUserApi
+  com.ning.billing.util.api.TagUserApi
+)
+
+begin
+  KILLBILL_APIS.each { |api| java_import api }
+rescue NameError
+  # killbill-api should be provided by the JRuby OSGI bundle. We default to using JBundler for development purposes only
+  begin
+    require 'jbundler'
+    KILLBILL_APIS.each { |api| java_import api }
+    warn 'Using JBundler to load killbill-api. This should only happen in development mode!'
+    warn "Classpath (see .jbundler/classpath.rb):\n\t#{JBUNDLER_CLASSPATH.join("\n\t")}"
+  rescue LoadError => e
+    warn 'Unable to load killbill-api and couldn\'t find JBundler. For development purposes, make sure to run: `bundle install && jbundle install\' from the killbill gem source tree'
+  end
+end
+
+require 'killbill/notification'
+require 'killbill/payment'

data/lib/killbill/notification.rb

@@ -0,0 +1,14 @@
+require 'killbill/plugin'
+
+module Killbill
+  module Plugin
+    class Notification < PluginBase
+
+      # Override this method in your plugin to act upon received events
+      def on_event(event)
+        # no-op
+      end
+
+    end
+  end
+end

data/lib/killbill/payment.rb

@@ -0,0 +1,44 @@
+require 'killbill/plugin'
+
+module Killbill
+  module Plugin
+    class Payment < PluginBase
+
+      class OperationUnsupportedByGatewayError < NotImplementedError
+      end
+
+      def charge(external_account_key, killbill_payment_id, amount_in_cents, options = {})
+        raise OperationUnsupportedByGatewayError
+      end
+
+      def refund(external_account_key, killbill_payment_id, amount_in_cents, options = {})
+        raise OperationUnsupportedByGatewayError
+      end
+
+      def get_payment_info(killbill_payment_id, options = {})
+        raise OperationUnsupportedByGatewayError
+      end
+
+      def add_payment_method(external_account_key, payment_method, options = {})
+        raise OperationUnsupportedByGatewayError
+      end
+
+      def delete_payment_method(external_account_key, external_payment_method_id, options = {})
+        raise OperationUnsupportedByGatewayError
+      end
+
+      def update_payment_method(external_account_key, payment_method, options = {})
+        raise OperationUnsupportedByGatewayError
+      end
+
+      def set_default_payment_method(external_account_key, payment_method, options = {})
+        raise OperationUnsupportedByGatewayError
+      end
+
+      def create_account(killbill_account, options = {})
+        raise OperationUnsupportedByGatewayError
+      end
+
+    end
+  end
+end

data/lib/killbill/plugin.rb

@@ -0,0 +1,64 @@
+module Killbill
+  # There are various types of plugins one can write for Killbill:
+  #
+  #   1)  notifications plugins, which listen to external bus events and can react to it
+  #   2)  payment plugins, which are used to issue payments against a payment gateway
+  module Plugin
+    class PluginBase
+
+      attr_reader :active
+
+      # Called by the Killbill lifecycle when initializing the plugin
+      def start_plugin
+        @active = true
+      end
+
+      # Called by the Killbill lifecycle when stopping the plugin
+      def stop_plugin
+        @active = false
+      end
+
+      attr_accessor :account_user_api,
+                    :analytics_sanity_api,
+                    :analytics_user_api,
+                    :catalog_user_api,
+                    :entitlement_migration_api,
+                    :entitlement_timeline_api,
+                    :entitlement_transfer_api,
+                    :entitlement_user_api,
+                    :invoice_migration_api,
+                    :invoice_payment_api,
+                    :invoice_user_api,
+                    :meter_user_api,
+                    :overdue_user_api,
+                    :payment_api,
+                    :tenant_user_api,
+                    :usage_user_api,
+                    :audit_user_api,
+                    :custom_field_user_api,
+                    :export_user_api,
+                    :tag_user_api
+
+      # Called by the Killbill lifecycle when instantiating the plugin
+      def initialize(apis_map = {})
+        @active = false
+
+        apis_map.each do |api_name, api_instance|
+          begin
+            self.send("#{api_name}=", api_instance)
+          rescue NoMethodError
+            warn "Ignoring unsupported API: #{api_name}"
+          end
+        end
+      end
+
+      class APINotAvailableError < NotImplementedError
+      end
+
+      def method_missing(m, *args, &block)
+        raise APINotAvailableError.new("API #{m} is not available") if m =~ /_api$/
+      end
+
+    end
+  end
+end

data/lib/killbill/rake_task.rb

@@ -0,0 +1,185 @@
+require 'bundler'
+require 'logger'
+require 'pathname'
+require 'rake'
+require 'rake/packagetask'
+
+module Killbill
+  class PluginHelper
+    include Rake::DSL
+
+    class << self
+      def install_tasks(opts = {})
+        new(opts[:base_name] || Dir.pwd,                # Path to the plugin root directory (where the gempec and/or Gemfile should be)
+            opts[:plugin_name],                         # Plugin name, e.g. 'klogger'
+            opts[:gem_name],                            # Gem file name, e.g. 'klogger-1.0.0.gem'
+            opts[:gemfile_name] || "Gemfile",           # Gemfile name
+            opts[:gemfile_lock_name] || "Gemfile.lock") # Gemfile.lock name
+        .install
+      end
+    end
+
+    def initialize(base_name, plugin_name, gem_name, gemfile_name, gemfile_lock_name)
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+
+      @base_name = base_name
+      @plugin_name = plugin_name
+      @gem_name = gem_name
+      @gemfile_name = gemfile_name
+      @gemfile_lock_name = gemfile_lock_name
+
+      # Plugin base directory
+      @base = Pathname.new(@base_name).expand_path
+
+      # Find the gemspec to determine name and version
+      @plugin_gemspec = find_plugin_gemspec
+
+      # Temporary build directory
+      # Don't use 'pkg' as it is used by Rake::PackageTask already: it will
+      # hard link all files from @package_dir to pkg to avoid tar'ing up symbolic links
+      @package_dir = Pathname.new(name).expand_path
+
+      # Staging area to install gem dependencies
+      # Note the Killbill friendly structure (which we will keep in the tarball)
+      @target_dir = @package_dir.join("#{version}/gems").expand_path
+
+      # Staging area to install the killbill.properties file
+      @killbill_properties_target_dir = @package_dir.join("#{version}").expand_path
+    end
+
+    def specs
+      # Rely on the Gemfile definition, if it exists, to get all dependencies
+      # (we assume the Gemfile includes the plugin gemspec, as it should).
+      # Otherwise, use only the plugin gemspec.
+      @specs ||= @gemfile_definition ? @gemfile_definition.specs : [@plugin_gemspec]
+    end
+
+    def install
+      namespace :killbill do
+        desc "Validate plugin tree"
+        task :validate => killbill_properties_file do
+          validate
+        end
+
+        # Build the .tar.gz and .zip packages
+        task :package => :stage
+        package_task = Rake::PackageTask.new(name, version) do |p|
+          p.need_tar_gz = true
+          p.need_zip = true
+        end
+
+        desc "Stage all dependencies"
+        task :stage => :validate do
+          stage_dependencies
+          stage_killbill_properties_file
+
+          # Small hack! Update the list of files to package (Rake::FileList is evaluated too early above)
+          package_task.package_files = Rake::FileList.new("#{@package_dir.basename}/**/*")
+        end
+
+        desc "List all dependencies"
+        task :dependency => :validate do
+          print_dependencies
+        end
+
+        desc "Delete #{@package_dir}"
+        task :clean => :clobber_package do
+          rm_rf @package_dir
+        end
+      end
+    end
+
+    private
+
+    def validate
+      @plugin_gem_file    = find_plugin_gem
+      @gemfile_definition = find_gemfile
+    end
+
+    def print_dependencies
+      puts "Gems to be staged:"
+      specs.each { |spec| puts "  #{spec.name} (#{spec.version})" }
+    end
+
+    def name
+      @plugin_gemspec.name
+    end
+
+    def version
+      @plugin_gemspec.version
+    end
+
+    # Parse the <plugin_name>.gemspec file
+    def find_plugin_gemspec
+      gemspecs = @plugin_name ? [File.join(@base, "#{@plugin_name}.gemspec")] : Dir[File.join(@base, "{,*}.gemspec")]
+      raise "Unable to find your plugin gemspec in #{@base}" unless gemspecs.size == 1
+      spec_path = gemspecs.first
+      @logger.debug "Parsing #{spec_path}"
+      Bundler.load_gemspec(spec_path)
+    end
+
+    def find_plugin_gem
+      if @gem_name
+        # Absolute path?
+        plugin_gem_file = Pathname.new(@gem_name).expand_path
+        # Relative path to the base?
+        plugin_gem_file = @base.join(@gem_name).expand_path unless plugin_gem_file.file?
+        raise "Unable to find your plugin gem in #{@base}. Did you build it (`rake build')?" unless plugin_gem_file.file?
+      else
+        plugin_gem_files = Dir[File.join(@base, "**/#{name}-#{version}.gem")]
+        @logger.debug "Gem candidates found: #{plugin_gem_files}"
+        raise "Unable to find your plugin gem in #{@base}. Did you build it? (`rake build')" unless plugin_gem_files.size >= 1
+        # Take the first one, assume the other ones are from build directories (e.g. pkg)
+        plugin_gem_file = plugin_gem_files.first
+      end
+
+      @logger.debug "Found #{plugin_gem_file}"
+      Pathname.new(plugin_gem_file).expand_path
+    end
+
+    # Parse the existing Gemfile and Gemfile.lock files
+    def find_gemfile
+      gemfile = @base.join(@gemfile_name).expand_path
+      # Don't make the Gemfile a requirement, a gemspec should be enough
+      return nil unless gemfile.file?
+
+      # Make sure the developer ran `bundle install' first. We could probably run
+      #   Bundler::Installer::install(@target_dir, @definition, {})
+      # but it may be better to make sure all dependencies are resolved first,
+      # before attempting to build the plugin
+      gemfile_lock = @base.join(@gemfile_lock_name).expand_path
+      raise "Unable to find the Gemfile.lock at #{gemfile_lock} for your plugin. Please run `bundle install' first" unless gemfile_lock.file?
+
+      @logger.debug "Parsing #{gemfile} and #{gemfile_lock}"
+      Bundler::Definition.build(gemfile, gemfile_lock, nil)
+    end
+
+    def stage_dependencies
+      # Create the target directory
+      mkdir_p @target_dir.to_s
+
+      @logger.debug "Installing all gem dependencies to #{@target_dir}"
+      # We can't simply use Bundler::Installer unfortunately, because we can't tell it to copy the gems for cached ones
+      # (it will default to using Bundler::Source::Path references to the gemspecs on "install").
+      specs.each do |spec|
+        # For the plugin itself, install it manually (the cache path is likely to be wrong)
+        next if spec.name == name and spec.version == version
+        @logger.debug "Staging #{spec.name} (#{spec.version}) from #{spec.cache_file}"
+        Gem::Installer.new(spec.cache_file, {:force => true, :install_dir => @target_dir}).install
+      end
+
+      @logger.debug "Staging #{name} (#{version}) from #{@plugin_gem_file}"
+      Gem::Installer.new(@plugin_gem_file, {:force => true, :install_dir => @target_dir}).install
+    end
+
+    def stage_killbill_properties_file
+      @logger.debug "Staging #{killbill_properties_file} to #{@killbill_properties_target_dir}"
+      cp killbill_properties_file, @killbill_properties_target_dir
+    end
+
+    def killbill_properties_file
+      @base.join("killbill.properties").expand_path.to_s
+    end
+  end
+end

data/spec/killbill/base_plugin_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+class LifecycleNotificationPlugin < Killbill::Plugin::PluginBase
+  attr_accessor :lifecycled
+
+  def start_plugin
+    @lifecycled = true
+    super
+  end
+
+  def stop_plugin
+    @lifecycled = true
+    super
+  end
+end
+
+describe Killbill::Plugin::PluginBase do
+  it 'should be able to register Killbill API instances' do
+    plugin = Killbill::Plugin::PluginBase.new(:account_user_api => MockAccountUserApi.new)
+
+    plugin.account_user_api.get_accounts(nil).size.should == 0
+    lambda { plugin.foobar_user_api.do_foo('with my bar') }.should raise_error Killbill::Plugin::PluginBase::APINotAvailableError
+  end
+
+  it 'should be able to add custom code in the startup/shutdown sequence' do
+    plugin = LifecycleNotificationPlugin.new
+
+    plugin.lifecycled = false
+    plugin.lifecycled.should be_false
+    plugin.active.should be_false
+
+    plugin.start_plugin
+    plugin.lifecycled.should be_true
+    plugin.active.should be_true
+
+    plugin.lifecycled = false
+    plugin.lifecycled.should be_false
+    plugin.active.should be_true
+
+    plugin.stop_plugin
+    plugin.lifecycled.should be_true
+    plugin.active.should be_false
+  end
+end

data/spec/killbill/killbill_integration_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+java_import 'java.util.UUID'
+java_import 'org.joda.time.DateTimeZone'
+java_import 'com.ning.billing.catalog.api.Currency'
+java_import 'com.ning.billing.mock.api.MockBillCycleDay'
+
+describe Killbill::Plugin do
+  before(:each) do
+    @account_user_api = MockAccountUserApi.new
+  end
+
+  it 'should be able to access Killbill mock APIs' do
+    @account_user_api.createAccount(UUID.randomUUID,
+                                    'externalKey',
+                                    'email',
+                                    'name',
+                                    1,
+                                    Currency::USD,
+                                    MockBillCycleDay.new(12),
+                                    UUID.randomUUID,
+                                    DateTimeZone::UTC,
+                                    'locale',
+                                    'address1',
+                                    'address2',
+                                    'companyName',
+                                    'city',
+                                    'stateOrProvince',
+                                    'country',
+                                    'postalCode',
+                                    'phone')
+    account = @account_user_api.getAccountByKey('externalKey', nil)
+    account.external_key.should == 'externalKey'
+    account.email.should == 'email'
+    account.name.should == 'name'
+    account.first_name_length.should == 1
+    account.currency.should == Currency::USD
+    account.payment_method_id.should_not be_nil
+    account.time_zone.should == DateTimeZone::UTC
+    account.locale.should == 'locale'
+    account.address1.should == 'address1'
+    account.address2.should == 'address2'
+    account.company_name.should == 'companyName'
+    account.city.should == 'city'
+    account.state_or_province.should == 'stateOrProvince'
+    account.country.should == 'country'
+    account.postal_code.should == 'postalCode'
+    account.phone.should == 'phone'
+  end
+end
+

data/spec/killbill/notification_plugin_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+class DummyNotificationPlugin < Killbill::Plugin::Notification
+end
+
+class HoarderNotificationPlugin < Killbill::Plugin::Notification
+  attr_reader :events
+
+  def start_plugin
+    @events = []
+    super
+  end
+
+  def on_event(event)
+    @events << event
+  end
+
+  def stop_plugin
+    super
+    @events = []
+  end
+end
+
+describe Killbill::Plugin::Notification do
+  before(:each) do
+    @event = Hash.new(:account_id => SecureRandom.uuid)
+  end
+
+  it "should not raise exceptions by default" do
+    plugin = DummyNotificationPlugin.new
+    lambda { plugin.on_event(@event) }.should_not raise_error
+  end
+
+  it "should be able to receive all events" do
+    plugin = HoarderNotificationPlugin.new
+
+    plugin.start_plugin
+    plugin.events.size.should == 0
+
+    (1..100).each do |i|
+      plugin.on_event(@event)
+      plugin.events.size.should == i
+      plugin.events[-1].should == @event
+    end
+
+    plugin.stop_plugin
+    plugin.events.size.should == 0
+  end
+end

data/spec/killbill/payment_plugin_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+class DummyPaymentPlugin < Killbill::Plugin::Payment
+end
+
+describe Killbill::Plugin::Payment do
+  before(:each) do
+    @external_account_key = SecureRandom.uuid
+    @killbill_payment_id = SecureRandom.uuid
+    @amount_in_cents = rand(100000)
+
+    @payment_method = Hash.new(:credit_card => SecureRandom.uuid)
+    @external_payment_method_id = SecureRandom.uuid
+
+    @killbill_account = Hash.new(:name => SecureRandom.uuid)
+
+    @plugin = DummyPaymentPlugin.new
+  end
+
+  it "should raise exceptions for unsupported operations" do
+    lambda { @plugin.charge(@external_account_key, @killbill_payment_id, @amount_in_cents) }.should raise_error Killbill::Plugin::Payment::OperationUnsupportedByGatewayError
+    lambda { @plugin.refund(@external_account_key, @killbill_payment_id, @amount_in_cents) }.should raise_error Killbill::Plugin::Payment::OperationUnsupportedByGatewayError
+    lambda { @plugin.get_payment_info(@killbill_payment_id) }.should raise_error Killbill::Plugin::Payment::OperationUnsupportedByGatewayError
+    lambda { @plugin.add_payment_method(@external_account_key, @payment_method) }.should raise_error Killbill::Plugin::Payment::OperationUnsupportedByGatewayError
+    lambda { @plugin.delete_payment_method(@external_account_key, @external_payment_method_id) }.should raise_error Killbill::Plugin::Payment::OperationUnsupportedByGatewayError
+    lambda { @plugin.update_payment_method(@external_account_key, @payment_method) }.should raise_error Killbill::Plugin::Payment::OperationUnsupportedByGatewayError
+    lambda { @plugin.set_default_payment_method(@external_account_key, @payment_method) }.should raise_error Killbill::Plugin::Payment::OperationUnsupportedByGatewayError
+    lambda { @plugin.create_account(@killbill_account) }.should raise_error Killbill::Plugin::Payment::OperationUnsupportedByGatewayError
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require 'bundler'
+require 'killbill'
+
+%w(
+  MockAccountUserApi
+  MockEntitlementUserApi
+).each do |api|
+  begin
+    java_import "com.ning.billing.mock.api.#{api}"
+  rescue LoadError
+  end
+end
+
+require 'rspec'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.tty = true
+  config.formatter = 'documentation'
+end
+
+begin
+  require 'securerandom'
+  SecureRandom.uuid
+rescue LoadError, NoMethodError
+  # See http://jira.codehaus.org/browse/JRUBY-6176
+  module SecureRandom
+    def self.uuid
+      ary = self.random_bytes(16).unpack("NnnnnN")
+      ary[2] = (ary[2] & 0x0fff) | 0x4000
+      ary[3] = (ary[3] & 0x3fff) | 0x8000
+      "%08x-%04x-%04x-%04x-%04x%08x" % ary
+    end unless respond_to?(:uuid)
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: killbill
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 1.0.0
+platform: ruby
+authors:
+- Killbill core team
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jbundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+    none: false
+  prerelease: false
+  type: :development
+description: Base classes to write plugins.
+email: killbilling-users@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Jarfile
+- README.md
+- Rakefile
+- VERSION
+- killbill.gemspec
+- lib/killbill.rb
+- lib/killbill/notification.rb
+- lib/killbill/payment.rb
+- lib/killbill/plugin.rb
+- lib/killbill/rake_task.rb
+- spec/killbill/base_plugin_spec.rb
+- spec/killbill/killbill_integration_spec.rb
+- spec/killbill/notification_plugin_spec.rb
+- spec/killbill/payment_plugin_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.killbilling.org
+licenses:
+- Apache License (2.0)
+post_install_message:
+rdoc_options:
+- --exclude
+- .
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      hash: 2
+      version: !binary |-
+        MA==
+  none: false
+requirements:
+- jar 'com.ning.billing:killbill-api', '0.1.48'
+- jar 'com.ning.billing:killbill-util:tests', '0.1.48'
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Framework to write Killbill plugins in Ruby.
+test_files:
+- spec/killbill/base_plugin_spec.rb
+- spec/killbill/killbill_integration_spec.rb
+- spec/killbill/notification_plugin_spec.rb
+- spec/killbill/payment_plugin_spec.rb
+- spec/spec_helper.rb