cloud_financial_officer 0.1.0

data/spec/lib/cfo/record_grouper_spec.rb

@@ -0,0 +1,110 @@
+module CFO
+  include CloudCostTracker::Billing
+  describe RecordGrouper do
+
+    before(:all) do
+      BillingRecord.delete_all
+      BillingCode.delete_all
+      # We'll Create 16 BillingRecords so we can perform a tertiary sort,
+      # and still collapse the total Records to 8 by the grouping operation.
+      @groupings = ['account', 'project', 'environment']
+      # First, the BillingCodes must be created
+      BillingCode.create!(:key => 'project', :value => 'balance')
+      BillingCode.create!(:key => 'project', :value => 'imedidata')
+      BillingCode.create!(:key => 'environment', :value => 'sandbox')
+      BillingCode.create!(:key => 'environment', :value => 'validation')
+      BillingCode.create!(:key => 'environment', :value => 'innovate')
+      BillingCode.create!(:key => 'environment', :value => 'production')
+      # Except for the grouping fields, plus one extra field, resource_type,
+      # all records with have the same data...
+      @start, @stop, @per_record_cost = Time.now, (Time.now + 60), 1
+      [ # first, create 8 unique permuations of the @groupings
+      # Account | 'code:project' | 'code:environment' | resource_type (dropped)
+        [ 'dev',    'balance',        'sandbox',          'Server'],
+        [ 'dev',    'balance',        'validation',       'Server'],
+        [ 'dev',    'imedidata',      'sandbox',          'Server'],
+        [ 'dev',    'imedidata',      'validation',       'Server'],
+        [ 'prod',   'balance',        'innovate',         'Server'],
+        [ 'prod',   'balance',        'production',       'Server'],
+        [ 'prod',   'imedidata',      'innovate',         'Server'],
+        [ 'prod',   'imedidata',      'production',       'Server'],
+      # Now, make the same permutations, but with a different resource_type
+        [ 'dev',    'balance',        'sandbox',          'Volume'],
+        [ 'dev',    'balance',        'validation',       'Volume'],
+        [ 'dev',    'imedidata',      'sandbox',          'Volume'],
+        [ 'dev',    'imedidata',      'validation',       'Volume'],
+        [ 'prod',   'balance',        'innovate',         'Volume'],
+        [ 'prod',   'balance',        'production',       'Volume'],
+        [ 'prod',   'imedidata',      'innovate',         'Volume'],
+        [ 'prod',   'imedidata',      'production',       'Volume'],
+      ].map do |record_data|
+        BillingRecord.create!(
+          :account => record_data[0], :service => 'Compute', :provider => 'AWS',
+          :resource_type => record_data[3], :resource_id => "id-#{rand 65535}",
+          :start_time => @start, :stop_time => @stop, :cost_per_hour => 60,
+          :total_cost => @per_record_cost, :billing_type => 'whatever',
+          :billing_codes => [
+            BillingCode.where(:key => 'project', :value => record_data[1]).
+              first_or_create!,
+            BillingCode.where(:key => 'environment', :value => record_data[2]).
+              first_or_create!,
+          ]
+        )
+      end
+    end
+
+    describe '#by' do
+      before(:each) do
+        @results = RecordGrouper.by(@groupings, BillingRecord.all)
+      end
+
+      it "merges all Records with the same unique permutation of groupings" do
+        # make sure there are the right number of records for the above example
+        @results.should have(8).things
+      end
+      it "returns records with a total cost equal to the input's total" do
+        @results.each do |record|
+          record.total_cost.should == 2 * @per_record_cost
+        end
+        total = @results.inject(0) {|t,record| t += record.total_cost}
+        total.should == BillingRecord.count * @per_record_cost
+      end
+      it "returns composite records with shared component record values" do
+        @results.each do |record|
+          record.service.should       == 'Compute'
+          record.provider.should      == 'AWS'
+          record.billing_type.should  == 'whatever'
+          record.resource_type.should == RecordGrouper::MULTIPLE_VALUES_VALUE
+          record.resource_id.should   == RecordGrouper::MULTIPLE_VALUES_VALUE
+        end
+      end
+
+      context "when invoked with groupings that don't match all input records" do
+        before(:all) do
+          # Create 2 new records that don't match the groupings (in the same way)
+          2.times do
+            BillingRecord.create!(
+              :account => 'other account', :service => 'Compute', :provider => 'RDS',
+              :resource_type => 'Snapshot', :resource_id => "id-#{rand 65535}",
+              :start_time => @start, :stop_time => @stop, :cost_per_hour => 60,
+              :total_cost => @per_record_cost, :billing_type => 'whatever')
+          end
+          @results = RecordGrouper.by(@groupings, BillingRecord.all)
+        end
+        it "treats all matches for a given BillingCode as a single group" do
+          @results.should have(9).things  # a new composite record
+          non_matching_record = @results.find {|r| r.account == 'other account'}
+          non_matching_record.billing_codes.should be_empty
+          non_matching_record.total_cost.should == 2 * @per_record_cost
+        end
+        it "returns records with a total cost equal to the input's total" do
+          @results.each do |record|
+            record.total_cost.should == 2 * @per_record_cost
+          end
+          total = @results.inject(0) {|t,record| t += record.total_cost}
+          total.should == BillingRecord.count * @per_record_cost
+        end
+      end
+    end
+  end
+end

data/spec/lib/cfo/resources/account_spec.rb

@@ -0,0 +1,46 @@
+module CFO
+  describe Account do
+
+    before(:each) do
+      @account = build(:account,
+        :billing_codes => [['key1', 'val1'], ['key2', 'val2']]
+      )
+    end
+
+    describe '#to_hash' do
+      it "returns a hash of the account's attributes, with name as ID" do
+        account_hash = @account.to_hash
+        account_hash['id'].should             == @account.name
+        account_hash['service'].should        == @account.service
+        account_hash['provider'].should       == @account.provider
+        account_hash['billing_codes'].should  ==
+                [['key1', 'val1'], ['key2', 'val2']]
+      end
+      it "returns a URI link to itself" do
+        @account.to_hash['url'].should ==
+          "#{CFO.root}/accounts/#{URI.escape(@account.name)}"
+      end
+    end
+
+    describe '#uri' do
+      it "returns a URI link to itself" do
+        @account.uri.should == "#{CFO.root}/accounts/#{URI.escape(@account.name)}"
+      end
+    end
+
+    describe '#report_uri' do
+      it "returns a URI for its cost report" do
+        @account.report_uri.should ==
+          "#{CFO.root}/report/for_account/#{URI.escape(@account.name)}"
+      end
+    end
+
+    describe '#to_json' do
+      it "returns a JSON version of the #to_hash output" do
+        account_hash = @account.to_hash
+        @account.to_json.should == @account.to_hash.to_json
+      end
+    end
+
+  end
+end

data/spec/lib/cfo/resources/cloud_resource_spec.rb

@@ -0,0 +1,90 @@
+module CFO
+  describe CloudResource do
+
+    before(:each) do
+      @resource = build(:resource, {
+        :billing_codes  => [['key1', 'val1'], ['key2', 'val2']],
+        :account        => build(:account),
+      })
+    end
+
+    describe '#to_hash' do
+      context "when invoked with verbose=false" do
+        it "returns a hash of the resource's attributes" do
+          resource_hash = @resource.to_hash(false)
+          resource_hash['resource_id'].should   == @resource.resource_id
+          resource_hash['resource_type'].should == @resource.resource_type
+        end
+      end
+      context "when invoked with verbose=true" do
+        it "returns information on its account" do
+          account_data = @resource.to_hash(true)['account']
+          account_data['id'].should       == @resource.account.name
+          account_data['service'].should  == @resource.account.service
+          account_data['provider'].should == @resource.account.provider
+          account_data['url'].should      ==
+            "#{CFO.root}/accounts/#{URI.escape(@resource.account.name)}"
+        end
+        it "returns a billing codes and the resource list as well" do
+          resource_hash = @resource.to_hash(true)
+          resource_hash['billing_codes'].should ==
+            [['key1', 'val1'], ['key2', 'val2']]
+        end
+      end
+    end
+
+    describe '#uri' do
+      it "returns a URI link to itself" do
+        @resource.uri.should ==
+          "#{CFO.root}/accounts/#{URI.escape(@resource.account.name)}"+
+          "/#{URI.escape(@resource.resource_type)}"+
+          "/#{URI.escape(@resource.resource_id)}"
+      end
+    end
+
+    describe '#report_uri' do
+      it "returns a URI link to its cost report" do
+        account = @resource.account
+        @resource.report_uri.should ==
+          "#{CFO.root}/report/for_account/#{URI.escape(account.name)}/for_type/"+
+            "#{URI.escape(@resource.resource_type)}/for_resource/"+
+            "#{URI.escape(@resource.resource_id)}"
+      end
+    end
+
+    describe '#to_json' do
+      it "returns a JSON version of the #to_hash output" do
+        resource_hash = @resource.to_hash
+        @resource.to_json.should == @resource.to_hash.to_json
+      end
+    end
+
+    describe '#hash_list' do
+      before(:each) do
+        CloudCostTracker::Billing::BillingRecord.delete_all
+        # Create a pair of distinct BillingRecords
+        @resource1 = create(:record,{:resource_id => 'fake-resource-1'})
+        @resource2 = create(:record,{:resource_id => 'fake-resource-2'})
+      end
+      context "when invoked with no conditions" do
+        it "returns an Array of all CloudResource Hash representations" do
+          resource_list = CloudResource.hash_list
+          resource_list.should have(2).things
+          (resource_list.map {|r| r['resource_id']}).should ==
+            [@resource1.resource_id, @resource2.resource_id]
+        end
+      end
+      context "when invoked with conditions" do
+        it "returns an Array of all matching CloudResource Hashes" do
+          resource_list = CloudResource.hash_list(
+            :resource_id => @resource1.resource_id
+          )
+          resource_list.should have(1).thing
+          (resource_list.map {|r| r['resource_id']}).should ==
+            [@resource1.resource_id]
+        end
+      end
+    end
+
+  end
+end

data/spec/lib/cfo/resources/report_spec.rb

@@ -0,0 +1,264 @@
+module CFO
+  include CloudCostTracker::Billing
+
+  describe Report do
+
+    # Number of BillingRecords to report on
+    NUM_RECORDS = 50  # Each has its own unique provider, service, etc.
+
+    before(:all) do
+      BillingRecord.delete_all
+      @billing_start = DateTime.parse((Time.now - (RECORD_DURATION + 1)).to_s)
+      # Create many BillingRecords, each with its own unique attributes
+      (1..NUM_RECORDS).each do |i|
+        create(:record, {
+          :provider       => "#{PROVIDER_NAME}#{i}",
+          :service        => "#{SERVICE_NAME}#{i}",
+          :account        => "#{ACCOUNT_NAME}#{i}",
+          :resource_id    => "#{RESOURCE_ID}#{i}",
+          :resource_type  => "#{RESOURCE_TYPE}#{i}",
+          :billing_type   => "#{BILLING_TYPE}#{i}",
+        })
+      end
+      @billing_stop = DateTime.parse((Time.now + 1).to_s)
+    end
+
+    after(:all) do
+      BillingRecord.delete_all
+    end
+
+    describe '#to_json' do
+      it "renders a summary of the included billing records" do
+        report_hash = JSON.parse(Report.new.to_json)
+        report_hash['start_time'].should ==
+          report_hash['billing_records'].first['start_time']
+        report_hash['stop_time'].should ==
+          report_hash['billing_records'].last['stop_time']
+        report_hash['total_cost'].should be_a Numeric
+        report_hash['total_cost'].should == NUM_RECORDS * RECORD_TOTAL
+        report_hash['cost_per_hour'].should be_a Numeric
+        report_duration = Time.parse(report_hash['stop_time']) -
+          Time.parse(report_hash['start_time'])
+        report_hash['cost_per_hour'].should be_within(0.01).
+          of(SECONDS_PER_HOUR * report_hash['total_cost'] / report_duration)
+      end
+
+      # CONSTRAIN BY ACCOUNT NAME
+      context "when invoked with a matching account name constraint" do
+        it "returns a report on all the account's BillingRecords" do
+          # now search for a random account
+          account_name = "#{ACCOUNT_NAME}#{rand(NUM_RECORDS) + 1}"
+          constraint = {'for_account' => account_name}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.size.should == 1
+          billing_records.first['account'].should == account_name
+        end
+      end
+      context "when invoked with a non-matching account name constraint" do
+        it "returns a report with no BillingRecords" do
+          # now search for a bogus account
+          constraint = {'for_account' => "UN-FINDABLE NAME"}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.should be_empty
+        end
+      end
+
+      # CONSTRAIN BY RESOURCE ID
+      context "when invoked with a matching resource ID constraint" do
+        it "returns a report on all the resource's BillingRecords" do
+          # now search for a resource ID
+          resource_id = "#{RESOURCE_ID}#{rand(NUM_RECORDS) + 1}"
+          constraint = {'for_resource' => resource_id}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.size.should == 1
+          billing_records.first['resource_id'].should == resource_id
+        end
+      end
+      context "when invoked with a non-matching resource ID constraint" do
+        it "returns a report with no BillingRecords" do
+          # now search for a bogus resource ID
+          constraint = {'for_resource' => "UN-FINDABLE NAME"}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.should be_empty
+        end
+      end
+
+      # CONSTRAIN BY RESOURCE TYPE
+      context "when invoked with a matching resource type constraint" do
+        it "returns a report on all the resource's BillingRecords" do
+          # now search for a resource type
+          resource_type = "#{RESOURCE_TYPE}#{rand(NUM_RECORDS) + 1}"
+          constraint = {'for_type' => resource_type}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.size.should == 1
+          billing_records.first['resource_type'].should == resource_type
+        end
+      end
+      context "when invoked with a non-matching resource type constraint" do
+        it "returns a report with no BillingRecords" do
+          # now search for a bogus resource type
+          constraint = {'for_type' => "UN-FINDABLE NAME"}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.should be_empty
+        end
+      end
+
+      # CONSTRAIN BY PROVIDER
+      context "when invoked with a matching provider constraint" do
+        it "returns a report on all the provider's BillingRecords" do
+          # now search for a provider
+          provider = "#{PROVIDER_NAME}#{rand(NUM_RECORDS) + 1}"
+          constraint = {'for_provider' => provider}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.size.should == 1
+          billing_records.first['provider'].should == provider
+        end
+      end
+      context "when invoked with a non-matching provider constraint" do
+        it "returns a report with no BillingRecords" do
+          # now search for a bogus provider
+          constraint = {'for_provider' => "UN-FINDABLE NAME"}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.should be_empty
+        end
+      end
+
+      # CONSTRAIN BY SERVICE
+      context "when invoked with a matching service constraint" do
+        it "returns a report on all the service's BillingRecords" do
+          # now search for a service
+          service = "#{SERVICE_NAME}#{rand(NUM_RECORDS) + 1}"
+          constraint = {'for_service' => service}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.size.should == 1
+          billing_records.first['service'].should == service
+        end
+      end
+      context "when invoked with a non-matching service constraint" do
+        it "returns a report with no BillingRecords" do
+          # now search for a bogus service
+          constraint = {'for_service' => "UN-FINDABLE NAME"}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.should be_empty
+        end
+      end
+
+      # CONSTRAIN BY BILLING TYPE
+      context "when invoked with a matching billing type constraint" do
+        it "returns a report on all the BillingRecords of that type" do
+          # now search for a billing type
+          billing_type = "#{BILLING_TYPE}#{rand(NUM_RECORDS) + 1}"
+          constraint = {'for_billing_type' => billing_type}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.size.should == 1
+          billing_records.first['billing_type'].should == billing_type
+        end
+      end
+      context "when invoked with a non-matching billing type constraint" do
+        it "returns a report with no BillingRecords" do
+          # now search for a bogus billing type
+          constraint = {'for_billing_type' => "UN-FINDABLE NAME"}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.should be_empty
+        end
+      end
+
+      # CONSTRAIN BY TIME
+      context "when invoked with a time constraint encompassing all records" do
+        it "returns a report on all the BillingRecords" do
+          # now search on a time range encompassing all records
+          constraint = {'for_time' => [@billing_start, Time.now]}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.size.should == NUM_RECORDS
+          first_start = DateTime.parse(billing_records.first['start_time'])
+          last_stop = DateTime.parse(billing_records.last['stop_time'])
+          first_start.should >= @billing_start
+          last_stop.should <= @billing_stop
+        end
+      end
+      context "when invoked with a single non-matching time constraint" do
+        it "returns a report with no BillingRecords" do
+          # now search for a zero-second time range
+          constraint = {'for_time' => [Time.now + 60, Time.now + 60]}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          billing_records.should be_empty
+        end
+      end
+      context "with a time constraint that partially overlaps a record" do
+        it "truncates the partially overlapped record" do
+          a_record = BillingRecord.first
+          record_duration = a_record.stop_time - a_record.start_time
+          query_start = a_record.start_time + (record_duration / 2)
+          constraint = {'for_time' => [query_start, Time.now]}
+          response = Report.new([constraint]).to_json
+          billing_records = JSON.parse(response)['billing_records']
+          first_start = Time.parse(billing_records.first['start_time'])
+          first_stop = Time.parse(billing_records.first['stop_time'])
+          first_start.should be_within(1).of query_start
+          first_stop.should be_within(1).of a_record.stop_time
+        end
+      end
+
+      # CONSTRAIN BY BILLING CODE
+      context "when coded records exist" do
+        before(:all) do
+          coded_record = BillingRecord.first
+          coded_record.billing_codes =
+            [BillingCode.new(:key => 'codekey', :value => 'codevalue')]
+          coded_record.save!
+        end
+        context "when invoked with a fully-matching code constraint" do
+          it "returns only BillingRecords with matching code" do
+            # now search for the coded record
+            constraint = {'for_code' => ['codekey', 'codevalue']}
+            response = Report.new([constraint]).to_json
+            billing_records = JSON.parse(response)['billing_records']
+            billing_records.size.should == 1
+            billing_records.first['billing_codes'].should ==
+              [[ 'codekey', 'codevalue' ]]
+          end
+        end
+        context "when invoked with a matching wildcard constraint" do
+          it "returns only BillingRecords with matching code" do
+            constraint = {'for_code' => ['codekey', '*']}
+            response = Report.new([constraint]).to_json
+            billing_records = JSON.parse(response)['billing_records']
+            billing_records.size.should == 1
+            billing_records.first['billing_codes'].should ==
+              [[ 'codekey', 'codevalue' ]]
+            constraint = {'for_code' => ['*', 'codevalue']}
+            response = Report.new([constraint]).to_json
+            billing_records = JSON.parse(response)['billing_records']
+            billing_records.size.should == 1
+            billing_records.first['billing_codes'].should ==
+              [[ 'codekey', 'codevalue' ]]
+          end
+        end
+        context "when invoked with only non-matching code constraints" do
+          it "returns a report with no BillingRecords" do
+            # now search for the coded record
+            constraint = {'for_code' => ['XXXXXXXXXX', '*']}
+            response = Report.new([constraint]).to_json
+            billing_records = JSON.parse(response)['billing_records']
+            billing_records.should be_empty
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/cfo/service_spec.rb

@@ -0,0 +1,103 @@
+module CFO
+  describe Service do
+    include Rack::Test::Methods
+    def app ; CFO::Service end
+
+    before(:all) do
+      @accounts = FogTracker.validate_accounts(
+        YAML.load(File.read('./config/accounts.yml')))
+    end
+
+    describe 'GET /' do
+      it "returns a list of the accounts" do
+        get "#{CFO.root}"
+        account_data = JSON.parse(last_response.body)
+        account_data.size.should == @accounts.size
+        account_data.each do |account|
+          @accounts.keys.should include(account['id'])
+          @accounts[account['id']][:service].should == account['service']
+          @accounts[account['id']][:provider].should == account['provider']
+        end
+      end
+    end
+
+    describe 'GET /accounts' do
+      it "returns a list of the accounts" do
+        get "#{CFO.root}/accounts"
+        account_data = JSON.parse(last_response.body)
+        account_data.size.should == @accounts.size
+        account_data.each do |account|
+          @accounts.keys.should include(account['id'])
+          @accounts[account['id']][:service].should == account['service']
+          @accounts[account['id']][:provider].should == account['provider']
+        end
+      end
+    end
+
+    describe 'GET /resources' do
+      it "returns a list of all known cloud computing resources" do
+        CloudCostTracker::Billing::BillingRecord.delete_all
+        # Create a pair of BillingRecords
+        resource1 = create(:record,{:resource_id => 'fake-resource-1'})
+        resource2 = create(:record,{:resource_id => 'fake-resource-2'})
+        get "#{CFO.root}/resources"
+        resource_data = JSON.parse(last_response.body)
+        (resource_data.map {|r| r['resource_id']}).should ==
+          ['fake-resource-1', 'fake-resource-2']
+      end
+    end
+
+    describe 'GET /accounts/:account_name' do
+      context "when passed a valid account name" do
+        it "returns the JSON representation of the account named :account_name" do
+          account = @accounts[@accounts.keys.sort.first]
+          get "#{CFO.root}/accounts/#{URI.escape(@accounts.keys.sort.first)}"
+          account_data = JSON.parse(last_response.body)
+          account_data['id'].should == @accounts.keys.sort.first
+          account_data['service'].should == account[:service]
+          account_data['provider'].should == account[:provider]
+        end
+      end
+      context "when passed an invalid account name" do
+        it "returns a 404 with an error message" do
+          get "#{CFO.root}/accounts/INVALID-ACCOUNT-NAME"
+          last_response.status.should == 404
+          error_data = JSON.parse(last_response.body)
+          error_data.keys.should include('error')
+        end
+      end
+    end
+
+    describe 'GET /accounts/:account_name/:type/:resource_id' do
+      before(:each) do
+        CloudCostTracker::Billing::BillingRecord.delete_all
+        @record = create(:record)
+        @record_url = "#{CFO.root}/accounts/#{URI.escape(@record.account)}"+
+          "/#{URI.escape(@record.resource_type)}"+
+          "/#{URI.escape(@record.resource_id)}"
+      end
+      after(:each) {CloudCostTracker::Billing::BillingRecord.delete_all}
+
+      context "when passed a matching account name, resource type, and ID" do
+        it "returns the JSON representation of the matching resource" do
+          get @record_url
+          resource_data = JSON.parse(last_response.body)
+          resource_data['resource_id'].should == @record.resource_id
+          resource_data['resource_type'].should == @record.resource_type
+          resource_data['account']['id'].should == @record.account
+          resource_data['account']['service'].should == @record.service
+          resource_data['account']['provider'].should == @record.provider
+        end
+      end
+      context "when passed non-matching data" do
+        it "returns a 404 with an error message" do
+          get "#{@record_url}XXXXXXXXXXXXXXXXX"
+          last_response.status.should == 404
+          error_data = JSON.parse(last_response.body)
+          error_data.keys.should include('error')
+        end
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+require 'active_record'
+ENV['RACK_ENV'] ||= 'test'
+
+## Establish ActiveRecord connection and Migrate database
+# The following db config files are used, in order of preference:
+#   1. ENV['DB_CONFIG_FILE']
+#   2. ./config/database.yml
+#   3. ./config/database.example.yml
+db_conf_file = './config/database.example.yml'
+db_conf_file = './config/database.yml' if File.exists? './config/database.yml'
+if ENV['DB_CONFIG_FILE']
+  db_conf_file = ENV['DB_CONFIG_FILE']
+else
+  ENV['DB_CONFIG_FILE'] = db_conf_file
+end
+puts "Reading DB config file #{db_conf_file}..."
+db_config = YAML::load(File.open(db_conf_file))[ENV['RACK_ENV'] || 'test']
+puts "Using DB #{db_config['database']}..."
+ActiveRecord::Base.establish_connection(db_config)
+ActiveRecord::Migrator.migrate(
+File.join(Gem.loaded_specs['cloud_cost_tracker'].full_gem_path,
+  'db', 'migrate'), ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+)
+
+require './lib/cloud_financial_officer'
+require './spec/factories'
+require 'rack/test'
+
+# Require RSpec support files. Logging is configured there
+support_files = Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")]
+support_files.sort.each {|f| require f}
+
+# RSpec configuration block
+RSpec.configure do |config|
+  config.mock_with :rspec   # == Mock Framework
+  config.include FactoryGirl::Syntax::Methods
+end

data/spec/support/_configure_logging.rb

@@ -0,0 +1,6 @@
+# Setup a global Logger for all tests
+LOG_LEVEL = ::Logger::WARN
+LOG = FogTracker.default_logger(STDOUT)
+LOG.info "Logging configured in #{File.basename __FILE__}."
+LOG.level = LOG_LEVEL
+ActiveRecord::Base.logger = LOG  # Uncomment for ActiveRecord outputs