aws-sdk-cloudwatch 0.0.6 → 1.0.0.rc1

data/lib/aws/core/option_grammar/double.rb

@@ -1,29 +0,0 @@
-require 'aws/core/inflection'
-require 'aws/core/option_grammar'
-require 'aws/core/meta_utils'
-
-module AWS
-  module Core
-    class OptionGrammar
-      module Descriptors
-        
-        # @private
-        module Double
-  
-          extend NoArgs
-  
-          def validate(value, context = nil)
-            raise format_error("float value", context) unless
-              value.respond_to? :to_f
-          end
-  
-          def encode_value(value)
-            value.to_s
-          end
-  
-        end
-        
-      end
-    end
-  end
-end

data/licence.rb

@@ -1,14 +0,0 @@
-# Copyright 2012 Inscitiv
-# 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-

data/spec/cloud_watch_client_spec.rb

@@ -1,27 +0,0 @@
-# Copyright 2012 Inscitiv
-# 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'aws/cloud_watch/client'
-
-describe AWS::CloudWatch::Client, '.api_config' do
-  it 'loads api config from proper directory' do
-    expected_dir = Pathname.new(File.dirname(__FILE__)).parent
-    expected_file = expected_dir.to_s + '/lib/aws/api_config/CloudWatch-2010-08-01.yml'
-    
-    File.should_receive(:read).with(expected_file).and_return(file = double)
-    YAML.should_receive(:load).with(file).and_return(api = double)
-    
-    AWS::CloudWatch::Client.api_config.should == api
-  end
-end

data/spec/cloud_watch_ec2_spec.rb

@@ -1,70 +0,0 @@
-# Copyright 2012 Inscitiv
-# 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'aws/cloud_watch/ec2'
-
-describe AWS::EC2::Instance, '#metrics' do
-  it 'returns the collection of metrics filtered by the instance' do
-    inst = AWS::EC2::Instance.new :test_id
-    ms = inst.metrics
-    ms.kind_of? AWS::CloudWatch::MetricCollection.should be_true
-    ms.namespace.should == 'AWS/EC2'
-    ms.dimensions[:instance_id].should == :test_id
-  end
-  
-  it 'always returns the same instance of the collection' do
-    inst = AWS::EC2::Instance.new :test_id
-    ms = inst.metrics
-    inst.metrics.should === ms
-  end
-end
-
-describe AWS::EC2::Instance, '#cpu_utilization' do
-  before :each do
-    @inst = AWS::EC2::Instance.new :some_id
-  end
-
-  it 'uses the proper metrics' do
-    @inst.cpu_utilization.name.should == 'CPUUtilization'
-  end
-  
-  it 'aggregates by average by default' do
-    @inst.should_receive(:metrics).and_return(double :[] => (metric = double))
-    metric.should_receive(:average).with(:some, :args).and_return(result = double)
-    
-    @inst.cpu_utilization(:some, :args).should == result
-  end
-end
-
-describe AWS::EC2::Instance, ' synthetic metric methods' do
-  before :each do
-    @inst = AWS::EC2::Instance.new :some_id
-    @ms = @inst.metrics
-  end
-  
-  it 'retrieves the proper metric and aggregates by sum' do
-    [:disk_read_ops, :disk_write_ops, :network_out, :disk_read_bytes, :network_in, :disk_write_bytes].each do |name|
-      @inst.send(name).name == name
-    end
-  end
-  
-  it 'aggregates the metric with sum' do
-    [:disk_read_ops, :disk_write_ops, :network_out, :disk_read_bytes, :network_in, :disk_write_bytes].each do |name|
-      @ms.should_receive(:[]).with(name).and_return(metric = double)
-      metric.should_receive(:sum).with(:some, :args).and_return(result = double)
-      
-      @inst.send(name, :some, :args).should == result
-    end
-  end
-end

data/spec/metric_base_spec.rb

@@ -1,50 +0,0 @@
-# Copyright 2012 Inscitiv
-# 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'aws/cloud_watch/metric_base'
-
-describe AWS::CloudWatch::MetricBase do
-  it 'puts unknown keys in dimensions when initializing' do
-    mb = AWS::CloudWatch::MetricBase.new :name => :foo,
-        'Something' => :bar, :other => :baz
-    mb.name.should == :foo
-    mb.dimensions[:other].should == :baz
-    mb.dimensions['Something'].should == :bar
-  end
-end
-
-describe AWS::CloudWatch::MetricBase, '#dimensions=' do
-  it 'transforms argument into direct hash form' do
-    mb = AWS::CloudWatch::MetricBase.new({})
-    mb.dimensions = [{:name => 'Test', :value => 'dimension'}, 
-                     {:name => :another, :value => :dimension}]
-    mb.dimensions.should == {'Test' => 'dimension',
-                             :another => :dimension}
-  end
-end
-
-describe AWS::CloudWatch::MetricBase, '#options' do
-  it 'folds all parameters into a single hash ready for sending to AWS' do
-    mb = AWS::CloudWatch::MetricBase.new :name => :foo,
-        'Something' => :bar, :other => :baz
-    options = mb.options
-    options.keys.length.should == 2
-    options[:metric_name].should ==  :foo
-    dims = options[:dimensions]
-    dims.length.should == 2
-    [ { :name => 'Something', :value => :bar }, { :name => 'Other', :value => :baz } ].each do |dim|
-      dims.include?(dim).should be_true
-    end
-  end
-end

data/spec/metric_collection_spec.rb

@@ -1,46 +0,0 @@
-# Copyright 2012 Inscitiv
-# 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'aws/cloud_watch/metric_collection'
-
-describe AWS::CloudWatch::MetricCollection, '#each' do
-  it 'paginates through a token' do
-    mc = AWS::CloudWatch::MetricCollection.new({})
-    client = double("client")
-    mc.should_receive(:client).any_number_of_times.and_return(client)
-
-    names = [:one, :two, :three, :four]
-    first_page = names[0..1].map {|n| {:name => n}}
-    second_page = names[2..3].map {|n| {:name => n}}
-    
-    client.should_receive(:list_metrics).and_return(stub :metrics => first_page, :data => {:next_token => :a_token})
-    client.should_receive(:list_metrics) do |options|
-      options[:next_token].should == :a_token
-      stub :metrics => second_page, :data => {}
-    end
-    
-    mc.each do |metric|
-      metric.name.should == names.shift
-    end
-  end
-end
-
-describe AWS::CloudWatch::MetricCollection, '#[]' do
-  it 'makes a metric with the given name' do
-    mc = AWS::CloudWatch::MetricCollection.new :namespace => :foo
-    metric = mc[:some_name]
-    metric.name.should == 'SomeName'
-    metric.namespace.should == :foo
-  end
-end

data/spec/metric_spec.rb

@@ -1,159 +0,0 @@
-# Copyright 2012 Inscitiv
-# 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'aws/cloud_watch/metric'
-
-describe AWS::CloudWatch::Metric, '#options' do
-  it 'also takes the unit' do
-    m = AWS::CloudWatch::Metric.new :unit => 'barn'
-    m.options[:unit].should == 'barn'
-  end
-end
-
-describe AWS::CloudWatch::Metric, '#get' do
-  before(:each) do
-    @metric = AWS::CloudWatch::Metric.new({})
-    @metric.should_receive(:client).any_number_of_times.and_return(@client = double)
-    @begin = Time.utc(2000, 1, 2, 2, 2, 2)
-    @begin_iso = "2000-01-02T02:02:02Z"
-    @end = Time.utc(2000, 2, 2, 2, 2, 3)
-    @end_iso = "2000-02-02T02:02:03Z"
-  end
-  
-  it 'can collect a single statistic' do
-    @client.should_receive(:get_metric_statistics).with(\
-      :start_time => @begin_iso,
-      :end_time => @end_iso,
-      :period => 4600,
-      :statistics => ["Sum"]
-    ).and_return(double :datapoints => [])
-    @metric.get(:sum, 4600, @begin..@end)
-  end
-
-  it 'collects one period worth of data if no range is given' do
-    @client.should_receive(:get_metric_statistics).with(\
-      :start_time => "2000-02-02T01:02:03Z",
-      :end_time => @end_iso,
-      :period => 60*60, # one hour
-      :statistics => ["Sum"]
-    ).and_return(double :datapoints => [{:sum => :result}])
-    @metric.get(:sum, 60 * 60, @end).should == :result
-  end
-
-  it 'returns nil when no datapoinst are returned' do
-    @client.should_receive(:get_metric_statistics).with(\
-      :start_time => "2000-02-02T01:02:03Z",
-      :end_time => @end_iso,
-      :period => 60*60, # one hour
-      :statistics => ["Sum"]
-    ).and_return(double :datapoints => [])
-    @metric.get(:sum, 60 * 60, @end).should be_nil
-  end
-  
-  it 'returns stats sorted by timestamp' do
-    datapoints = [
-      {:timestamp => Time.utc(2001, 4, 2, 5, 2, 0)},
-      {:timestamp => Time.utc(2011, 3, 1, 12, 4, 32)},
-      {:timestamp => Time.utc(2000, 1, 5, 2, 3, 0)}
-    ]
-    sorted = [
-      {:timestamp => Time.utc(2000, 1, 5, 2, 3, 0)},
-      {:timestamp => Time.utc(2001, 4, 2, 5, 2, 0)},
-      {:timestamp => Time.utc(2011, 3, 1, 12, 4, 32)}
-    ]
-    
-    @client.should_receive(:get_metric_statistics).with(\
-      :start_time => @begin_iso,
-      :end_time => @end_iso,
-      :period => 4600,
-      :statistics => ["Sum"]
-    ).and_return(double :datapoints => datapoints)
-    @metric.get(:sum, 4600, @begin..@end).should == sorted
-  end
-  
-  it 'fetches many batches if number of datapoints is too large' do
-    _begin = Time.utc(2012, 01, 01, 0, 0, 0)
-    _end = Time.utc(2012, 01, 03, 0, 0, 0)
-    
-    @client.should_receive(:get_metric_statistics).with(\
-      :start_time => "2012-01-01T00:00:00Z",
-      :end_time => "2012-01-02T00:00:00Z",
-      :period => 60,
-      :statistics => ["Sum"]
-    ).and_return(double :datapoints => [1, 2, 3])
-    @client.should_receive(:get_metric_statistics).with(\
-      :start_time => "2012-01-02T00:00:00Z",
-      :end_time => "2012-01-03T00:00:00Z",
-      :period => 60,
-      :statistics => ["Sum"]
-    ).and_return(double :datapoints => [4, 5, 6])
-    @metric.get(:sum, 60, _begin.._end).should == [1, 2, 3, 4, 5, 6]
-  end
-  
-  it 'handles minute differences in begin and end times gracefully' do
-    _begin = Time.utc(2012, 6, 8, 17, 36, 58, 901063)
-    _end = Time.utc(2012, 6, 13, 17, 36, 58, 901588)
-    
-    @client.should_receive(:get_metric_statistics).with(\
-      :start_time => "2012-06-08T17:36:58Z",
-      :end_time => "2012-06-13T17:36:58Z",
-      :period => 300,
-      :statistics => ["Sum"]
-    ).and_return(double :datapoints => [1, 2, 3])
-    @client.should_not_receive(:get_metric_statistics).with(\
-      :start_time => "2012-06-13T17:36:58Z",
-      :end_time => "2012-06-13T17:36:58Z",
-      :period => 300,
-      :statistics => ["Sum"]
-    )
-    @metric.get(:sum, 300, _begin.._end).should == [1, 2, 3]
-  end
-  
-  it 'returns [] trivially if range is shorter than period' do
-    _begin = Time.utc(2012, 6, 8, 17, 36, 58)
-    _end = Time.utc(2012, 6, 8, 17, 41, 57)
-    @client.should_not_receive:get_metric_statistics
-    @metric.get(:sum, 300, _begin.._end).should == []
-  end
-end
-
-describe AWS::CloudWatch::Metric, " synthetic methods" do
-  before(:each) do
-    @metric = AWS::CloudWatch::Metric.new({})
-    @metric.stub(:client => (@client = double))
-    @begin = Time.utc(2000, 2, 2, 2, 2, 2)
-    @begin_iso = "2000-02-02T02:02:02Z"
-    @end = Time.utc(2000, 2, 2, 4, 2, 3)
-    @end_iso = "2000-02-02T04:02:03Z"
-  end
-  
-  it "fetches proper statistic and substitutes :value field" do
-    stats = {:average => 'Average',
-             :sum => 'Sum',
-             :sample_count => 'SampleCount',
-             :maximum => 'Maximum',
-             :minimum => 'Minimum'
-            }
-            
-    stats.keys.each do |name|
-      @client.should_receive(:get_metric_statistics).with(\
-        :start_time => @begin_iso,
-        :end_time => @end_iso,
-        :period => 60*60, # one hour
-        :statistics => [stats[name]]
-      ).and_return(double :datapoints => [{name => :result}])
-      @metric.send(name, 60 * 60, (@begin..@end))[0][:value].should == :result
-    end
-  end
-end