cloud_cost_tracker 0.1.0

data/lib/cloud_cost_tracker/extensions/fog_model.rb

@@ -0,0 +1,41 @@
+module CloudCostTracker
+  module Extensions
+    # Adds convenience methods to Fog::Model instances for tracking billing info
+    module FogModel
+
+      # Adds a billing code to this cloud computing resource
+      # (Has no effect if the identical key is alreay set)
+      # @param [String] key the key for the desired billing code
+      # @param [String] value the value for the desired billing code
+      def code(key, value)
+        @_billng_codes ||= Array.new
+        if not @_billng_codes.include?([key, value])
+          @_billng_codes.push [key, value]
+        end
+      end
+
+      # Adds a billing code to this cloud computing resource
+      # (Has no effect if the identical key is alreay set)
+      # @param [String] key the key for the desired billing code
+      # @param [String] value the value for the desired billing code
+      def remove_code(key, value)
+        @_billng_codes ||= Array.new
+        @_billng_codes.delete [key, value]
+      end
+
+      # Returns this resource's billing codes
+      # @return [Array [<String>, <String>]]
+      def billing_codes
+        @_billng_codes ||= Array.new
+        @_billng_codes
+      end
+
+    end
+  end
+end
+
+module Fog
+  class Model
+    include CloudCostTracker::Extensions::FogModel
+  end
+end

data/lib/cloud_cost_tracker/models/billing_code.rb

@@ -0,0 +1,14 @@
+module CloudCostTracker
+  module Billing
+    class BillingCode < ActiveRecord::Base
+
+      has_and_belongs_to_many :billing_records,
+        :join_table => 'billing_records_codes'
+
+      # Validations
+      validates :key,   :presence => true
+      #validates :value, :uniqueness => {:scope => :key}
+
+    end
+  end
+end

data/lib/cloud_cost_tracker/models/billing_record.rb

@@ -0,0 +1,88 @@
+module CloudCostTracker
+  module Billing
+    class BillingRecord < ActiveRecord::Base
+
+      has_and_belongs_to_many :billing_codes,
+        :join_table => 'billing_records_codes'
+
+      # Validations
+      validates_presence_of :provider, :service, :account,
+        :resource_id, :resource_type, :billing_type,
+        :start_time, :stop_time, :cost_per_hour, :total_cost
+      validates_associated :billing_codes
+
+      # Returns the most recent BillingRecord for the same resource as
+      # the billing_record, or nil of there are none.
+      # Note that if billing_record is already in the database, this
+      # method can return billing_record itself!
+      # @param [BillingRecord] other_billing_record the record to match
+      # @return [BillingRecord,nil] the latest "matching" BillingRecord
+      def self.most_recent_like(billing_record)
+        results = BillingRecord.where(
+          :provider       => billing_record.provider,
+          :service        => billing_record.service,
+          :account        => billing_record.account,
+          :resource_id    => billing_record.resource_id,
+          :resource_type  => billing_record.resource_type,
+          :billing_type   => billing_record.billing_type,
+        ).order(:stop_time).reverse_order.limit(1)
+        results.empty? ? nil : results.first
+      end
+
+      # Returns true if this BillingRecord's duration overlaps (inclusively)
+      # with that of other_billing_record. The minimum amount of time that can be
+      # between the records and still allow them to "overlap" can be increased
+      def overlaps_with(other_billing_record, min_proximity = 0)
+        return true if start_time == other_billing_record.start_time
+        first, second = nil, nil  # Which record started first?
+        if start_time < other_billing_record.start_time
+          first, second = self, other_billing_record
+        else
+          first, second = other_billing_record, self
+        end
+        second.start_time - first.stop_time <= min_proximity
+      end
+
+      # Changes the stop time of this BillingRecord to be that of the
+      # other_billing_record, then recalculates the total
+      def merge_with(other_billing_record)
+        self.stop_time = other_billing_record.stop_time
+        total = ((stop_time - start_time) * cost_per_hour) / 3600
+        self.total_cost = total
+        ActiveRecord::Base.connection_pool.with_connection {save!}
+      end
+
+      # Creates BillngCodes as necessary from codes, an Array of String pairs,
+      # and associates this BillingRecord with those BillingCodes.
+      # @param [Array <Array <String>>] codes the String pairs to use as codes
+      def set_codes(codes)
+        codes.each do |key, value|
+          self.billing_codes << ( # Find the matching BillingCode or make a new one
+            ActiveRecord::Base.connection_pool.with_connection do
+              BillingCode.where(:key => key, :value => value).first_or_create!
+            end
+          )
+        end
+      end
+
+      # @return [Hash] a Hash representation of this BillingRecord.
+      def to_hash
+        {
+          'id'            => id,
+          'provider'      => provider,
+          'service'       => service,
+          'account'       => account,
+          'resource_id'   => resource_id,
+          'resource_type' => resource_type,
+          'billing_type'  => billing_type,
+          'start_time'    => start_time,
+          'stop_time'     => stop_time,
+          'cost_per_hour' => cost_per_hour,
+          'total_cost'    => total_cost,
+          'billing_codes' => billing_codes.map {|c| [c.key, c.value]}
+        }
+      end
+
+    end
+  end
+end

data/lib/cloud_cost_tracker/tasks.rb

@@ -0,0 +1,3 @@
+# Load the tasks which are exported from this gem
+load "#{File.dirname(__FILE__)}/../../lib/tasks/database.rake"
+load "#{File.dirname(__FILE__)}/../../lib/tasks/track.rake"

data/lib/cloud_cost_tracker/tracker.rb

@@ -0,0 +1,86 @@
+module CloudCostTracker
+
+  # Tracks the resources in one or more Fog accounts in an ActiveRecord database
+  class Tracker
+
+    # each CloudCostTracker is a thin wrapper around it's @tracker,
+    require 'fog_tracker'     # which is a FogTracker:Tracker
+    extend Forwardable        # most public methods are delegated
+    def_delegators :@tracker,:start,:stop,:query,:[],:update,
+            :running?,:types_for_account,:logger
+
+    attr_reader :accounts
+
+    # Creates an object for tracking Fog accounts in an ActiveRecord database
+    # @param [Hash] accounts a Hash of account information
+    #    (see accounts.yml.example)
+    # @param [Hash] options optional additional parameters:
+    #  - :delay (Integer) - Override time between polling of accounts
+    #    (should take a single Exception as its only required parameter)
+    #  - :logger - a Ruby Logger-compatible object
+    def initialize(accounts = {}, options={})
+      @delay    = options[:delay]
+      @log      = options[:logger] || FogTracker.default_logger
+      @running  = false
+      @accounts = setup_fog_tracker(accounts)
+    end
+
+    private
+
+    # Creates a FogTracker::Tracker that calls bill_for_account
+    # each time an account is refreshed
+    def setup_fog_tracker(accounts)
+      @tracker = FogTracker::Tracker.new(accounts,
+        {:delay => @delay, :logger => @log,
+          :callback => Proc.new do |resources|
+            checked_resources = sanity_check(resources)
+            code_resources(checked_resources)
+            bill_for_resources(checked_resources)
+          end
+        }
+      )
+      @tracker.accounts
+    end
+
+
+    # Make sure returned resources are billable and codeable
+    # @param [Array<Fog::Model>] resources the resources to check
+    # @return [Array<Fog::Model>] the resources deemed OK
+    def sanity_check(resources)
+      resources.select do |resource|
+        if resource.identity == nil
+          @log.warn "Found a Fog::Model with no identity. Removing it..."
+          @log.debug "BAD Fog::Model instance: #{resource.inspect}"
+          false   # return false from select to indicate resource is bad
+        else
+          true    # return true from select to indicate resource is OK
+        end
+      end
+    end
+
+    # Adds billing codes for all resources
+    def code_resources(resources)
+      return if resources.empty?
+      account = resources.first.tracker_account
+      @log.info "Generating billing codes for account #{account[:name]}"
+      coding_class = CloudCostTracker::account_coding_class(
+        account[:service], account[:provider])
+      coding_agent = coding_class.new(resources, {:logger => @log})
+      coding_agent.setup(resources)
+      coding_agent.code(resources)
+      @log.info "Generated billing codes for account #{account[:name]}"
+    end
+
+    # Generates BillingRecords for all Resources in account named +account_name+
+    def bill_for_resources(resources)
+      return if resources.empty?
+      account = resources.first.tracker_account
+      @log.info "Computing costs for account #{account[:name]}"
+      billing_agent = Billing::AccountBillingPolicy.new(
+                        resources, {:logger => @log})
+      billing_agent.setup(resources)
+      billing_agent.bill_for(resources)
+      @log.info "Wrote billing records for account #{account[:name]}"
+    end
+  end
+end

data/lib/cloud_cost_tracker/util/module_instrospection.rb

@@ -0,0 +1,13 @@
+# Makes the Module heirarchy needs to be inspectable
+class Module
+  def submodules
+    constants.collect {|const_name| const_get(const_name)}.select do |const|
+      const.class == Module
+    end
+  end
+  def classes
+    constants.collect {|const_name| const_get(const_name)}.select do |const|
+      const.class == Class
+    end
+  end
+end

data/lib/cloud_cost_tracker/version.rb

@@ -0,0 +1,3 @@
+module CloudCostTracker
+  VERSION = "0.1.0"
+end

data/lib/cloud_cost_tracker.rb

@@ -0,0 +1,113 @@
+require 'active_record'
+require 'logger'
+
+# Load generic ResourceBillingPolicy and Coding classes
+require 'cloud_cost_tracker/billing/resource_billing_policy'
+require 'cloud_cost_tracker/coding/resource_coding_policy'
+# Load all ruby files from 'cloud_cost_tracker' directory - except the tasks
+libs = Dir[File.join(File.dirname(__FILE__), "cloud_cost_tracker/**/*.rb")]
+libs.delete File.join(File.dirname(__FILE__), "cloud_cost_tracker/tasks.rb")
+libs.each {|f| require f}
+
+# Top-level module namespace - defines some static methods for mapping providers,
+# services and resources to their various Billing and Coding Policies
+module CloudCostTracker
+  # Returns the current RACK_ENV or RAILS_ENV, or 'development' if not set.
+  # @return [String] ENV[RACK_ENV] || ENV[RAILS_ENV] || development
+  def self.env
+    (ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development').downcase
+  end
+
+  # Connects to the database defined in db_file.
+  # Uses the YAML section indexed by {CloudCostTracker#env}.
+  # @param db_file the path to a Rails-style YAML DB config file.
+  # @return [Hash] the current envinronment's database configuration.
+  def self.connect_to_database(db_file = ENV['DB_CONFIG_FILE'])
+    db_file ||= "./config/database.yml"
+    all_dbs = YAML::load(File.read db_file)
+    if not ::ActiveRecord::Base.connected?
+      ::ActiveRecord::Base.establish_connection(all_dbs[CloudCostTracker.env])
+    end
+    all_dbs[CloudCostTracker.env]
+  end
+
+  # Loads account information defined in account_file.
+  # @param account_file the path to a YAML file (see accounts.yml.example).
+  # @return [Hash] the cleaned, validated Hash of account info.
+  def self.read_accounts(account_file = ENV['ACCOUNT_FILE'])
+    FogTracker.read_accounts(account_file)
+  end
+
+  # Creates and returns an Array of ResourceBillingPolicy (subclass) instances
+  # for billing the given +resource+, or an empty Array of none are found
+  # @param [Class] resource_class the Class object for the billed resource
+  # @param [Hash] options optional additional parameters:
+  #  - :logger - a Ruby Logger-compatible object
+  # @return [Array <ResourceBillingPolicy>] billing policy objects for resource
+  def self.create_billing_agents(resource_class, options = {})
+    agents = Array.new
+    # Safely descend through the Billing module Heirarchy
+    if matches = resource_class.name.match(%r{^Fog::(\w+)::(\w+)::(\w+)})
+      fog_svc, provider, model_name = matches[1], matches[2], matches[3]
+      if CloudCostTracker::Billing.const_defined? fog_svc
+        service_module = CloudCostTracker::Billing::const_get fog_svc
+        if service_module.const_defined? provider
+          provider_module = service_module.const_get provider
+          # Search through the classes in the module for all matches
+          classes = provider_module.classes.each do |policy_class|
+            if policy_class.name =~ /#{model_name}.*BillingPolicy/
+              agents << policy_class.new(:logger => options[:logger])
+            end
+          end
+        end
+      end
+    end
+    agents.sort {|a,b| a.class.name <=> b.class.name} # sort by class name
+  end
+
+  # Creates and returns an Array of ResourceCodingPolicy (subclass) instances
+  # for coding the given +resource+, or an empty Array of none are found
+  # @param [Class] resource_class the Class object for the billed resource
+  # @param [Hash] options optional additional parameters:
+  #  - :logger - a Ruby Logger-compatible object
+  # @return [Array <ResourceCodingPolicy>] coding policy objects for resource
+  def self.create_coding_agents(resource_class, options = {})
+    agents = Array.new
+    # Safely descend through the Coding module Heirarchy
+    if matches = resource_class.name.match(%r{^Fog::(\w+)::(\w+)::(\w+)})
+      fog_svc, provider, model_name = matches[1], matches[2], matches[3]
+      if CloudCostTracker::Coding.const_defined? fog_svc
+        service_module = CloudCostTracker::Coding::const_get fog_svc
+        if service_module.const_defined? provider
+          provider_module = service_module.const_get provider
+          # Search through the classes in the module for all matches
+          classes = provider_module.classes.each do |policy_class|
+            if policy_class.name =~ /#{model_name}.*CodingPolicy/
+              agents << policy_class.new(:logger => options[:logger])
+            end
+          end
+        end
+      end
+    end
+    agents.sort {|a,b| a.class.name <=> b.class.name} # sort by class name
+  end
+
+  # Returns a Class object, of the appropriate subclass of
+  # AccountCodingPolicy, given a Fog service and provider name.
+  # If none exists, returns CloudCostTracker::Coding::AccountCodingPolicy.
+  def self.account_coding_class(fog_service, provider)
+    agent_class = CloudCostTracker::Coding::AccountCodingPolicy
+    if CloudCostTracker::Coding.const_defined? fog_service
+      service_module = CloudCostTracker::Coding::const_get fog_service
+      if service_module.const_defined? provider
+        provider_module = service_module.const_get provider
+        if provider_module.const_defined? 'AccountCodingPolicy'
+          agent_class = provider_module.const_get 'AccountCodingPolicy'
+        end
+      end
+    end
+    agent_class
+  end
+
+
+end

data/lib/tasks/database.rake

@@ -0,0 +1,25 @@
+require 'active_record'
+require 'cloud_cost_tracker'
+
+namespace :db do
+  namespace :migrate do
+
+    desc "Conforms the schema of the tracker database. "+
+      "VERSION=[20120119000000] RACK_ENV=[development]"
+    task :tracker => :db_connect do
+      ActiveRecord::Migrator.migrate(
+      File.join(Gem.loaded_specs['cloud_cost_tracker'].full_gem_path,
+        'db', 'migrate'), ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+      )
+    end
+
+    task :db_connect do
+      config_file = ENV['DB_CONFIG_FILE'] || './config/database.yml'
+      puts "Using database config file #{config_file}..."
+      config = YAML::load(File.open(config_file))[CloudCostTracker.env]
+      puts "Using database #{config['database']}..."
+      ActiveRecord::Base.establish_connection(config)
+    end
+
+  end
+end

data/lib/tasks/rspec.rake

@@ -0,0 +1,6 @@
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ['--color', '--format documentation', '-r ./spec/spec_helper.rb']
+end

data/lib/tasks/track.rake

@@ -0,0 +1,19 @@
+desc "Runs the tracker [LOG_LEVEL=[INFO]]"
+task :track do
+  Rake::Task["db:migrate:db_connect"].invoke
+  require File.join(File.dirname(__FILE__), '..', 'cloud_cost_tracker')
+
+  # Setup logging
+  log = FogTracker.default_logger(STDOUT)
+  log.level = ::Logger.const_get((ENV['LOG_LEVEL'] || 'INFO').to_sym)
+
+  log.info "Loading account information..."
+  accounts = FogTracker.read_accounts './config/accounts.yml'
+
+  log.info "Loading custom coding policies..."
+  Dir["./config/policies/*.rb"].each {|f| require f}
+
+  CloudCostTracker::Tracker.new(accounts, {:logger => log}).start
+  while true do ; sleep 60 end    # Loop forever
+
+end

data/spec/lib/cloud_cost_tracker/billing/account_billing_policy_spec.rb

@@ -0,0 +1,33 @@
+module CloudCostTracker
+  module Billing
+    describe AccountBillingPolicy do
+
+      before(:each) do
+        @server = FAKE_AWS.servers.new
+        @db = FAKE_RDS.servers.new
+        @default_policy = AccountBillingPolicy.new([@server, @db])
+      end
+
+      describe '#setup' do
+        it "does nothing in the default implementation" do
+          (Proc.new {@default_policy.setup(nil)}).should_not raise_error
+        end
+      end
+
+      describe '#bill_for' do
+        it 'calls set, get_cost_for_duration, and write_billing_record_for'+
+           ' on each resource billing policy' do
+          resource_policy = double "fake ResourceBillingPolicy"
+          resource_policy.stub(:get_cost_for_duration).and_return 1.0
+          CloudCostTracker.stub(:create_billing_agents).and_return([resource_policy])
+          resource_policy.should_receive(:setup).with([@server, @db]).exactly(4).times
+          account_policy = AccountBillingPolicy.new([@server, @db])
+          resource_policy.should_receive(:get_cost_for_duration)
+          resource_policy.should_receive(:write_billing_record_for).exactly(2).times
+          account_policy.bill_for([@server, @db])
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/cloud_cost_tracker/billing/resource_billing_policy_spec.rb

@@ -0,0 +1,102 @@
+module CloudCostTracker
+module Billing
+describe ResourceBillingPolicy do
+
+  before(:each) do
+    BillingRecord.delete_all
+    @resource = FAKE_AWS.servers.new
+    @default_policy = ResourceBillingPolicy.new(:logger => LOG)
+    @end_time = Time.now
+    @start_time = @end_time - 3600   # one hour time span
+  end
+
+  after(:each) do
+    BillingRecord.delete_all
+  end
+
+  it "should expose a (null-impementation) setup method" do
+    (Proc.new {@default_policy.setup nil}).should_not raise_error
+  end
+
+  describe '#get_cost_for_duration' do
+    it 'should always return a cost of 1, even with nil arguments' do
+      @default_policy.get_cost_for_duration(nil, nil).should == 1.0
+    end
+  end
+
+  describe '#write_billing_record_for' do
+    before(:each) do
+      @resource.stub(:tracker_account).and_return(FAKE_ACCOUNT)
+      @resource.stub(:identity).and_return "fake server ID"
+      @resource.stub(:status).and_return "running"
+    end
+
+    context "when it calculates a zero cost for a resource" do
+      it "writes no billing record for the resource" do
+        BillingRecord.all.count.should == 0
+        @resource.stub(:status).and_return "stopped"
+        # This next line is not *really* stubbing the tested behavior --
+        # the default implementation of :get_cost_for_duration in
+        # the subject class must be overriden to test its effects in
+        # any implemented subclasses
+        @default_policy.stub(:get_cost_for_duration).and_return 0
+        @default_policy.write_billing_record_for(
+          @resource, 0.0, 0.0, @start_time, @end_time)
+        BillingRecord.all.count.should == 0
+      end
+    end
+
+    context "when a record exists with the same resource and billing type" do
+      before(:each) do
+        @existing_record = BillingRecord.new(
+          :provider       => FAKE_ACCOUNT[:provider],
+          :service        => FAKE_ACCOUNT[:service],
+          :account        => FAKE_ACCOUNT[:name],
+          :resource_id    => @resource.identity,
+          :resource_type  => 'Server',
+          :billing_type   => "ResourceBillingPolicy",
+          :start_time     => @start_time,
+          :stop_time      => @end_time,
+          :cost_per_hour  => 34.0,
+          :total_cost     => 34.0
+        )
+        BillingRecord.stub(:most_recent_like).and_return @existing_record
+      end
+      context "when the records match in hourly cost and billing codes" do
+        context "and they overlap in time" do
+          it "invokes merge_with on the existing record" do
+            @existing_record.should_receive(:merge_with)
+            @default_policy.write_billing_record_for(
+              @resource, 34.0, 34.0, @end_time, @end_time + 60)
+          end
+        end
+      end
+      context "when the new record differs in hourly rate or billing codes" do
+        it "writes a new record starting at the existing record's stop time" do
+          @existing_record.should_not_receive(:merge_with)
+          @default_policy.write_billing_record_for(
+            @resource, 5000000.0, 34.0, @end_time - 1, @end_time + 99)
+          result = BillingRecord.where(:resource_id => @resource.identity).last
+          result.start_time.to_s.should == @existing_record.stop_time.to_s
+        end
+      end
+    end
+
+    context 'with no existing record for the same resource and billing type' do
+      it "writes a new record" do
+        BillingRecord.stub(:find_last_matching_record).and_return(nil)
+        @default_policy.write_billing_record_for(
+          @resource, 0.0, 1.0, @start_time, @end_time)
+        results = BillingRecord.where(:resource_id => @resource.identity)
+        results.should_not be_empty
+        results.first.account.should == FAKE_ACCOUNT_NAME
+        results.first.provider.should == 'AWS'
+        results.first.service.should == 'Compute'
+        results.first.billing_type.should == 'ResourceBillingPolicy'
+      end
+    end
+  end
+
+end
+end
+end

data/spec/lib/cloud_cost_tracker/cloud_cost_tracker_spec.rb

@@ -0,0 +1,57 @@
+module CloudCostTracker
+
+  describe '#create_billing_agents' do
+    context "for a resource with only a single BillingPolicy defined" do
+      it "returns an Array with the correct ResourceBillingPolicy subclass" do
+        CloudCostTracker::create_billing_agents(FAKE_AWS.servers.new.class).
+          first.class.should == Billing::Compute::AWS::ServerBillingPolicy
+      end
+    end
+    context "for a resource with several BillingPolicy classes" do
+      it "returns an Array with the correct ResourceBillingPolicy subclasses" do
+        agents = CloudCostTracker::create_billing_agents(FAKE_RDS.servers.new.class)
+        agent_class_names = agents.map {|agent| agent.class.name.split('::').last}
+        agent_class_names.should ==
+          ['ServerBillingPolicy', 'ServerStorageBillingPolicy']
+      end
+    end
+    context "for a resource whose BillingPolicy class is not defined" do
+      it "returns an empty Array" do
+        CloudCostTracker::create_billing_agents(double("x").class).should == []
+      end
+    end
+  end
+
+  describe '#create_coding_agents' do
+    context "for a resource with only a single CodingPolicy defined" do
+      it "returns an Array with the correct ResourceCodingPolicy subclass" do
+        CloudCostTracker::create_coding_agents(FAKE_AWS.volumes.new.class).
+          first.class.should == Coding::Compute::AWS::VolumeCodingPolicy
+      end
+    end
+    context "for a resource with several CodingPolicy classes" do
+      #it "returns an Array with the correct ResourceCodingPolicy subclass" do
+      #  pending("need for multiple coding policies per resource")
+      #  agents = CloudCostTracker::create_coding_agents(FAKE_RDS.servers.new.class)
+      #  agent_classes = agents.map {|agent| agent.class.name.split('::').last}
+      #  agent_classes.should include 'ServerCodingPolicy'
+      #  agent_classes.should include 'ServerStorageCodingPolicy'
+      #end
+    end
+    context "for a resource whose CodingPolicy class is not defined" do
+      it "returns an empty Array" do
+        CloudCostTracker::create_coding_agents(double("x").class).should == []
+      end
+    end
+  end
+
+  describe '#account_coding_class' do
+    context "for a Fog service with an AccountCodingPolicy subclass" do
+      it "returns the correct AccountCodingPolicy subclass" do
+        CloudCostTracker::account_coding_class('Compute', 'AWS').
+          should == Coding::Compute::AWS::AccountCodingPolicy
+      end
+    end
+  end
+
+end

data/spec/lib/cloud_cost_tracker/coding/account_coding_policy_spec.rb

@@ -0,0 +1,32 @@
+module CloudCostTracker
+  module Coding
+    describe AccountCodingPolicy do
+
+      before(:each) do
+        @server = FAKE_AWS.servers.new
+        @db = FAKE_RDS.servers.new
+        @default_policy = AccountCodingPolicy.new([@server, @db])
+      end
+
+      describe '#setup' do
+        it "does nothing in the default implementation" do
+          (Proc.new {@default_policy.setup(nil)}).should_not raise_error
+        end
+      end
+
+      describe '#priority_classes' do
+        it "returns an empty Array in the default implementation" do
+          @default_policy.priority_classes.should == Array.new
+        end
+      end
+
+      describe '#code' do
+        it 'calls attach_account_codes on each resource' do
+          @default_policy.should_receive(:attach_account_codes).exactly(2).times
+          @default_policy.code([@server, @db])
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/cloud_cost_tracker/coding/resource_coding_policy_spec.rb

@@ -0,0 +1,23 @@
+module CloudCostTracker
+  module Coding
+    describe ResourceCodingPolicy do
+
+      before(:each) do
+        @resource = FAKE_AWS.servers.new
+        @default_policy = ResourceCodingPolicy.new
+      end
+
+      it "should expose a (null-impementation) setup method" do
+        (Proc.new {@default_policy.setup(nil)}).should_not raise_error
+      end
+
+      describe '#code' do
+        it 'should clear all billing codes the resource' do
+          @default_policy.code(@resource)
+          @resource.billing_codes.should == []
+        end
+      end
+
+    end
+  end
+end