shushu 0.1.16 → 1.0.0rc1

data/lib/helpers/http_helpers.rb

@@ -2,12 +2,6 @@ module Shushu
   module HttpHelpers
     extend self
 
-    def build_q_params(hash)
-      "?" + hash.map do |k, v|
-        CGI.escape("#{k}=#{v}")
-      end.join("&")
-    end
-
     def headers
       {
         :content_type => :json,

data/lib/models/{b_event.rb → billable_event.rb}

@@ -1,30 +1,25 @@
 module Shushu
-  module BEvent
-    extend self
+  class BillableEvent < Client
 
     OPEN = "open"
     CLOSE = "close"
 
-    def all
-      Shushu.handle_req {RestClient.get([Shushu.url, "/billable_events"].join, Shushu.headers)}
-    end
-
     def open(args)
       hid = args.delete(:hid) || args.delete("hid")
       entity_id = args.delete(:entity_id) || args.delete("entity_id")
       args[:state] = OPEN
-      Shushu.handle_req {RestClient.put(events_url(hid, entity_id), args, Shushu.headers)}
+      handle_req {RestClient.put(events_url(hid, entity_id), args, headers)}
     end
 
     def close(args)
       hid = args.delete(:hid) || args.delete("hid")
       entity_id = args.delete(:entity_id) || args.delete("entity_id")
       args[:state] = CLOSE
-      Shushu.handle_req {RestClient.put(events_url(hid, entity_id), args, Shushu.headers)}
+      handle_req {RestClient.put(events_url(hid, entity_id), args, headers)}
     end
 
     def events_url(hid, entity_id)
-      [Shushu.url, "/resources/#{hid}/billable_events/#{entity_id}"].join
+      [url, "/resources/#{hid}/billable_events/#{entity_id}"].join
     end
 
   end

data/lib/models/rate_code.rb

@@ -0,0 +1,20 @@
+module Shushu
+  class RateCode < Client
+    def create(args)
+      if args[:slug].nil?
+        handle_req do
+          RestClient.post(rate_codes_url, args, headers)
+        end
+      else
+        handle_req do
+          url = [rate_codes_url, args.delete(:slug)].join("/")
+          RestClient.put(url, args, headers)
+        end
+      end
+    end
+
+    def rate_codes_url
+      [url, "/rate_codes"].join
+    end
+  end
+end

data/lib/models/report.rb

@@ -1,68 +1,50 @@
+require 'ostruct'
+
 module Shushu
-  class Report
+  class Report < Client
     attr_accessor(
       :from,
       :to,
-      :billable_units
+      :billable_units,
+      :report
     )
 
-    def fetch
-      url = [Shushu.url, resource].join
-      Shushu.handle_req do
-        RestClient.get(url, {:params => {
-          :from => from.utc.to_s,
-          :to => to.utc.to_s
-        }})
+    def fetch(report_url, from, to)
+      @report = handle_req do
+        response_found = false
+        while !response_found
+          response = RestClient::Resource.new(report_url).get({:params => {
+            :from => from.utc.to_s,
+            :to => to.utc.to_s
+          }})
+
+          if response.code == 202
+            sleep 0.5
+          else
+            response_found = true
+          end
+        end
+        response
       end
+      self
     end
 
     def billable_units
-      @billable_units ||= report["billable_units"].map {|buh| BillableUnit.new(buh)}
+      @billable_units ||= report["billable_units"].map do |unit_hash|
+        OpenStruct.new(unit_hash).tap { |o| o.extend Totalable }
+      end
     end
 
     def total
       report["total"]
     end
-
-    def report
-      @report ||= fetch
-    end
-  end
-
-  class UsageReport < Report
-    attr_accessor :account_id
-
-    def initialize(account_id, from, to)
-      @account_id, @from, @to = account_id, from, to
-    end
-
-    def resource
-      "/accounts/#{@account_id}/usage_reports"
-    end
-  end
-
-  class Invoice < Report
-    attr_accessor :payment_method_id
-
-    def initialize(payment_method_id, from, to)
-      @payment_method_id, @from, @to = payment_method_id, from, to
-    end
-
-    def resource
-      "/payment_methods/#{payment_method_id}/invoices"
-    end
   end
 
   class RateCodeReport < Report
-    attr_accessor :rate_code_slug
-
-    def initialize(rate_code_slug, from, to)
-      @rate_code_slug, @from, @to = rate_code_slug, from, to
-    end
+    attr_accessor :slug
 
-    def resource
-      "/rate_codes/#{rate_code_slug}/report"
+    def fetch(slug, from, to)
+      super(self.url + "/rate_codes/#{slug}", from, to)
     end
   end
-
 end

data/lib/shushu.rb

@@ -11,60 +11,34 @@ module Inflector
 end
 
 module Shushu
-  extend self
-  extend HttpHelpers
-
   ShushuException = Class.new(StandardError)
 
-  def url
-    Client.url
-  end
-
-  def url=(url)
-    Client.url = url
-  end
-
   class Client
-    def self.url=(url)
-      @@url = url
-    end
+    include HttpHelpers
 
-    def self.url
-      if defined?(@@url)
-        @@url
-      else
-        ENV["SHUSHU_URL"]
-      end
-    end
+    attr_accessor :url
 
-    def initialize(url)
-      self.class.url = url
+    def initialize(url = ENV["SHUSHU_URL"])
+      @url = url
     end
 
-    def [](api)
-      Shushu.const_get(Inflector.camelize(api))
+    def method_missing(method, *args, &block)
+      begin
+        klass = method.to_s.gsub(/s$/,'')
+        Shushu.const_get(Inflector.camelize(klass)).new(@url)
+      rescue NameError => e
+        raise NameError, "'#{method}' not a local variable, method, or Shushu classname"
+      end
     end
   end
 end
 
+# for ease of typing
+ShuShu = Shushu
 
-require "models/account"
-require "models/billable_unit"
+require "totalable"
+require "models/billable_event"
+require "models/resource_ownership"
+require "models/rate_code"
 require "models/report"
-require "models/unit_group"
-require "models/line_item"
-require "models/b_event"
-require "models/res_own"
-require "models/r_code"
-require "models/rev_rep"
 require "models/heart_beat"
-require "models/p_method"
-require "models/acct_own"
-
-require "services/line_item_builder"
-
-require "presenters/base_presenter"
-require "presenters/unit_group_presenter"
-require "presenters/unit_presenter"
-require "presenters/line_item_presenter"
-require "presenters/report_presenter"

data/lib/totalable.rb

@@ -0,0 +1,7 @@
+module Shushu
+  module Totalable
+    def total
+      rate.to_f * qty.to_f
+    end
+  end
+end

data/readme.md

@@ -13,109 +13,13 @@ $ export SHUSHU_URL=https://123:secret@shushu.heroku.com
 
 ## Usage
 
-There are two ways to interact with Shushu APIs using this client. The first
-approach will rely on the credentials in `SHUSHU_URL`.
+Instantiate a client to interact with the Shushu API.
 
-```ruby
-Shushu::BEvent.open({})
-```
-
-The second approach allows for credentials other than the ones stored in the
-`SHUSHU_URL`.
+`Client::new` defaults to using `ENV['SHUHSU_URL']` if one is not provided.
 
 ```ruby
 shushu = Shushu::Client.new("https://other_provider_id:other_provider_token@shushu.heroku.com")
-shushu[:b_event].open({})
-```
-
-### PaymentMethod
-
-This API deals primarily with credit cards. PaymentMethods can be created
-indipendintly of Accounts. You will need a payment_method to generate an
-invoice.
-
-Reference: [PaymentMethod API](https://github.com/heroku/shushud/blob/master/doc/payment_methods_api.md)
-
-Create a new payment method with encrypted values:
-
-```ruby
-PMethod.create(
-  :card_num => "some encrypted value",
-  :card_exp_year => "2012",
-  :card_exp_month => "12"
-)
-#=> {:id => "12345", :card_token => "abc123", :card_type => "visa", :card_last4 => "1111"}
-```
-
-Update a payment_method with a new credit card:
-
-```ruby
-PMethod.update(
-  :id => "001",
-  :card_num => "some encrypted value",
-  :card_exp_year => "2012",
-  :card_exp_month => "12"
-)
-#=> {:id => "001", :card_token => "abc123", :card_type => "visa", :card_last4 => "1111"}
-```
-
-Create a new payment_method with a token. Note, this endpoint is
-idempotent with respect to the id and token.
-
-```ruby
-PMethod.update(:id => "my-custom-id", :card_token => "abc123")
-#=> {:id => "my-custom-id", :card_token => "abc123"}
-```
-
-To mark a payment_method in such a way that credit card processing will be
-disabled:
-
-```ruby
-PMethod.update(:id => "001", :non_receivable => true)
-#=> {:id => "001", :non_receivable => true}
-```
-
-### Account
-
-This API deals with accounts which is a primitive for grouping resources. You
-will need an account to generate a usage report.
-
-```ruby
-Shushu::Account.create
-#=> {:id => "001"}
-```
-
-### AccountOwnership
-
-Use this API when you want to setup associations between Shushu accounts and
-Shushu payment_methods.
-
-Reference: [AccountOwnerships API](https://github.com/heroku/shushud/blob/master/doc/account_ownership_api.md)
-
-To associate an account with a payment_method:
-
-```ruby
-Shushu::AcctOwn.act(
-  :account_id        => vault_account_id,
-  :payment_method_id => payment_method_id,
-  :entity_id         => entity_id,
-  :time              => time
-)
-#=> {"payment_method_id"=>"123", "account_id"=>"1", "entity_id"=>"entity123"}
-```
-
-If you need to move one account to another payment_method, you will need to
-deactivate the previous relationship and activate a new one. To deactivate
-call this method:
-
-```ruby
-Shushu::AcctOwn.deact(
-  :account_id        => vault_account_id,
-  :payment_method_id => payment_method_id,
-  :entity_id         => entity_id,
-  :time              => time
-)
-#=> {"payment_method_id"=>"123", "account_id"=>"1", "entity_id"=>"entity123"}
+shushu.billable_events.open({})
 ```
 
 ### RateCode
@@ -126,7 +30,7 @@ RateCode. You can provide your own slug or a UUID will be generated for you. If
 Reference: [RateCode API](https://github.com/heroku/shushud/blob/master/doc/rate_code_api.md)
 
 ```ruby
-Shushu::RCode.create(
+client.rate_codes.create(
   :slug  => some_record.uuid,
   :rate  => 5,
   :group => "addon",
@@ -148,7 +52,7 @@ Let Shushu generate a UUID for the slug.
 Remember to save the slug somewhere so that you can present it with billable_events.
 
 ```ruby
-Shushu::RCode.create(
+client.rate_codes.create(
   :rate  => 5,
   :group => "addon",
   :period => "month",
@@ -176,7 +80,7 @@ When the app is created or it is joining a new account, activate the the
 resource_ownership record.
 
 ```ruby
-Shushu::ResOwn.act(
+client.resource_ownerships.act(
   :resource_id => resource_id,
   :entity_id   => entity_id,
   :account_id  => vault_account_id,
@@ -189,7 +93,7 @@ When an app is destroyed, or the app is moving to a new account_id,
 deactivate the resource_ownership record.
 
 ```ruby
-Shushu::ResOwn.deact(
+client.resource_ownerships.deact(
   :resource_id => resource_id,
   :entity_id   => entity_id,
   :account_id  => vault_account_id,
@@ -210,7 +114,7 @@ Reference: [BillableEvent API](https://github.com/heroku/shushud/blob/master/doc
 Open an event when you would like to start billing.
 
 ```ruby
-Shushu::BEvent.open(
+client.billable_events.open(
   :entity_id    => entity_id,
   :hid          => hid,
   :time         => time,
@@ -224,7 +128,7 @@ Shushu::BEvent.open(
 Don't forget to close it.
 
 ```ruby
-Shushu::BEvent.close(
+client.billable_events.close(
   :entity_id => entity_id,
   :hid       => hid,
   :rate_code => rate_code,
@@ -232,88 +136,10 @@ Shushu::BEvent.close(
 )
 ```
 
-### Invoice
-
-```ruby
-invoice = Shushu::Invoice.new(payment_method_id, from, to)
-invoice.billable_units
-```
-### UsageReport
-
-```ruby
-report = Shushu::UsageReport.new(account_id, from, to)
-report.billable_units
-```
-
 ### RateCodeReport
 
 ```ruby
-report = Shushu::RateCodeReport.new(rate_code_slug, from, to)
+report = client.rate_code_reports.fetch(rate_code_slug, from, to)
 report.total
 report.billable_units
 ```
-
-
-### Report Generation
-
-Invoices and UsageReports can be used for report generation. Basically, the
-report generation code expects a collection of BillableUnits. BillableUnits are
-returned from both the Invoice API and the UsageReport API. However, the details
-of the billable_units may be different with respect to the type of the report.
-
-#### Presenters
-
-Clients of this library will want to generate some sort of view for the reports, the
-presenter objects were created to aid with that effort. You should only need to
-use the presenters while building views. Each view wraps a simple model object.
-All of the models and presenters are derived from the billable_unit which is
-retreived from the remote API.
-
-Report --> LineItem --> UnitGroup --> Billable Unit
-
-#### ReportPresenter
-
-The report presenter is how you will kick off the process of generating a
-report. You hand it a report object, either a UsageReport or and Invoice, and
-using the reports billable_units, it will build the line_items and a set of
-line_item_presenters for the line_items.
-
-#### LineItemBuilder
-
-The ReportPresenter will create a set of line_items based upon the
-billable_units in the report. The default is to group things by HID. Thus there
-will be a line_item for each distinct HID in the set of billable_units. The
-builder will also give a collection of unit_groups to the line_item. By default,
-the unit_groups will be partitioned by the product_group. (i.e. dyno, addon)
-
-You can customize the LineItemBuilder by creating a new class that responds to
-build and passing it to the ReportPresenter.
-
-```ruby
-ReportPresenter.new(report, CustomLineItemBuilder)
-```
-
-#### LineItemPresenter
-
-The LineItemPresenter is responsible for handling the total and names of the
-line_items. It also manages the set of unit_groups. Since the default
-LineItemBuilder partitioned unit_groups based upon product_group, you can ask
-the LineItemPresenter for infomation about subsets of unit_groups. For instance:
-
-```ruby
-line_item_presenter.unit_group_presenters("dyno")
-line_item_presenter.unit_group_total("dyno")
-line_item_presenter.unit_group_qty("dyno")
-```
-#### UnitGroupPresenter
-
-UnitGroups are collections of billable_units that are partitioned by
-product_name. So if there exists a set of billable_units that all have
-product_group = "dyno" and product_name= "worker", then this presenter
-will give you information about that group.
-
-
-#### UnitPresenter
-
-Finally, the UnitPresenter wraps a billable_unit and exposes methods to show
-totals, quantities and other meta-data.

data/test/models/billable_event_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class BillableEventTest < ShushuTest
+  def setup
+    @client = Shushu::Client.new "http://example.com"
+    super
+  end
+
+  def test_open
+    api_resp_body = Shushu::HttpHelpers.enc_json(our_params)
+    FakeWeb.register_uri(:put,
+      "http://example.com/resources/app123/billable_events/1",
+      :body => api_resp_body
+    )
+    event = @client.billable_events.open(our_params)
+    assert_equal(1, event["entity_id"])
+  end
+
+  def test_close
+    api_resp_body = Shushu::HttpHelpers.enc_json(our_params)
+    FakeWeb.register_uri(:put,
+      "http://example.com/resources/app123/billable_events/1",
+      :body => api_resp_body
+    )
+    event = @client.billable_events.close(our_params)
+    assert_equal(1, event["entity_id"])
+  end
+
+  def our_params
+    {
+      :hid => "app123",
+      :entity_id => 1,
+      :rate_code => "RT01",
+      :time => Time.utc(2012,1).to_s,
+      :product_name => "web",
+      :description => "some command",
+      :qty => 1
+    }
+  end
+end
+

data/test/models/{r_code_test.rb → rate_code_test.rb}

@@ -1,6 +1,12 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 class RCodeTest < ShushuTest
+  def setup
+    @url    = "http://provider:password@shushu.heroku.com"
+    @client = Shushu::Client.new(@url)
+    super
+  end
+
   def test_create_without_slug
     our_params = {
       :rate          => 5,
@@ -10,12 +16,11 @@ class RCodeTest < ShushuTest
     api_resp_body = Shushu::HttpHelpers.enc_json(
       our_params.merge(:slug => "AO01")
     )
-    Shushu.url = "http://provider:password@shushu.heroku.com"
     FakeWeb.register_uri(:post,
-      (Shushu.url + "/rate_codes"),
+      (@url + "/rate_codes"),
       :body => api_resp_body
     )
-    rate_code = Shushu::RCode.create(our_params)
+    rate_code = @client.rate_codes.create(our_params)
     assert_equal("AO01", rate_code["slug"])
   end
 
@@ -30,14 +35,12 @@ class RCodeTest < ShushuTest
     api_resp_body = Shushu::HttpHelpers.enc_json(
       our_params.merge(:slug => slug)
     )
-    Shushu.url = "http://provider:password@shushu.heroku.com"
     FakeWeb.register_uri(:put,
-      (Shushu.url + "/rate_codes/#{slug}"),
+      (@url + "/rate_codes/#{slug}"),
       :body => api_resp_body
     )
-    rate_code = Shushu::RCode.create(our_params)
+    rate_code = @client.rate_codes.create(our_params)
     assert_equal(slug, rate_code["slug"])
-
   end
 end
 

data/test/reports_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class RateCodeReportTest < ShushuTest
+  def setup
+    @url    = "http://provider:password@shushu.heroku.com"
+    @client = Shushu::Client.new(@url)
+    super
+  end
+
+  def test_rate_code_report
+    FakeWeb.register_uri(:get,
+      Regexp.new(Regexp.escape(@url + "/rate_codes/GUID")),
+      :body => Shushu::HttpHelpers.enc_json({:billable_units => [{"rate" => 10, "qty" => 5}]})
+    )
+
+    report = @client.rate_code_reports.fetch("GUID", Time.mktime(2011,1,1), Time.mktime(2011,2,1))
+    assert_equal 50, report.billable_units.first.total
+  end
+end