outliers 0.3.3 → 0.5.0.beta1

data/lib/outliers/provider.rb

@@ -1,11 +1,11 @@
 module Outliers
   class Provider
 
-    attr_reader :credentials
+    attr_reader :account
 
-    def self.connect_to(credentials)
-      provider = credentials.fetch 'provider'
-      Outliers::Providers.name_map.fetch(provider).new credentials
+    def self.connect_to(account)
+      provider = account.fetch 'provider'
+      Outliers::Providers.name_map.fetch(provider).new account
     rescue KeyError
       raise Outliers::Exceptions::UnknownProvider.new "Unkown provider '#{provider.join('_').downcase}'."
     end
@@ -14,10 +14,10 @@ module Outliers
       (self.to_s.split('::') - ['Outliers', 'Providers']).map { |p| p.underscore }.join('_').downcase
     end
 
-    def initialize(credentials)
-      @credentials = credentials
+    def initialize(account)
+      @account = account
       @logger      = Outliers.logger
-      settings credentials.keys_to_sym
+      settings account.keys_to_sym
     end
 
     def logger

data/lib/outliers/resources/aws/ec2/instance.rb

@@ -25,7 +25,7 @@ module Outliers
           end
 
           def valid_image_id?(args)
-            image_ids = Array(args[:image_ids])
+            image_ids = Array(args)
 
             logger.debug "Verifying Image ID '#{image_id}' is one of '#{image_ids.join(', ')}'."
             image_ids.include? image_id

data/lib/outliers/resources/aws/elb/load_balancer.rb

@@ -5,7 +5,7 @@ module Outliers
         class LoadBalancer < Resource
 
           def ssl_certificates_valid?(args)
-            days = args[:days]
+            days = args
             pass = true
 
             logger.debug "Load Balancer '#{id}' has no certificates." unless certificates.any?

data/lib/outliers/resources/aws/rds/db_instance.rb

@@ -8,7 +8,7 @@ module Outliers
           end
 
           def backup_retention_period?(args)
-            days = args[:days]
+            days = args
 
             current = source.backup_retention_period
             logger.debug "Verifying '#{id}' retention period of '#{current}' equals '#{days}' days."

data/lib/outliers/resources/aws/s3/bucket_collection.rb

@@ -5,7 +5,7 @@ module Outliers
         class BucketCollection < Collection
 
           def load_all
-            unless provider.credentials['region'] == 'us-east-1'
+            unless provider.account['region'] == 'us-east-1'
               raise Exceptions::UnsupportedRegion.new "Bucket verifications must target region us-east-1."
             end
             connect.buckets.map {|r| resource_class.new r}

data/lib/outliers/result.rb

@@ -1,18 +1,34 @@
+require 'json'
+
 module Outliers
   class Result
 
-    attr_reader :evaluation, :failing_resources, :passing_resources, :resource, :verification
+    attr_reader :account_name, :arguments, :failing_resources, :name, :passing_resources,
+                :provider_name, :resource_name, :verification_name
+
+    def to_json
+      to_hash.to_json
+    end
+
+    def to_hash
+      { 'account_name'      => account_name,
+        'arguments'         => arguments,
+        'name'              => name,
+        'provider_name'     => provider_name,
+        'resource_name'     => resource_name,
+        'verification_name' => verification_name,
+        'resources'         => resources }
+    end
 
     def initialize(args)
-      @evaluation        = args[:evaluation]
+      @account_name      = args[:account_name]
+      @arguments         = args[:arguments]
       @failing_resources = args[:failing_resources]
+      @name              = args[:name] || 'unspecified'
       @passing_resources = args[:passing_resources]
-      @resource          = args[:resource]
-      @verification      = args[:verification]
-    end
-
-    def to_s
-      passed? ? 'passed' : 'failed'
+      @provider_name     = args[:provider_name]
+      @resource_name     = args[:resource_name]
+      @verification_name = args[:verification_name]
     end
 
     def passed?
@@ -23,5 +39,13 @@ module Outliers
       @failing_resources.any?
     end
 
+    private
+
+    def resources
+      r = passing_resources.map{|r| { 'id' => r.id, 'passing' => 1 } }
+      r += failing_resources.map{|r| { 'id' => r.id, 'passing' => 0 } }
+      r
+    end
+
   end
 end

data/lib/outliers/run.rb

@@ -1,6 +1,6 @@
 module Outliers
   class Run
-    attr_accessor :credentials, :results, :threads, :threaded, :thread_count
+    attr_accessor :account, :results, :threads, :threaded, :thread_count
 
     def initialize(options={})
       @results                  = []
@@ -29,14 +29,20 @@ module Outliers
 
       evaluation = Proc.new { Evaluation.new(:name => name, :run => self).instance_eval &block }
 
+      if name
+        logger.info "Loading evaluation '#{name}'."
+      else
+        logger.info "Loading unnamed evaluation."
+      end
+
       threaded ? threads << Thread.new { evaluation.call } : evaluation.call
     end
 
-    def passed
+    def passing_results
       @results.select {|r| r.passed?}
     end
 
-    def failed
+    def failing_results
       @results.reject {|r| r.passed?}
     end
 

data/lib/outliers/verifications/shared.rb

@@ -7,8 +7,8 @@ module Outliers
       end
 
       def equals?(args)
-        keys = Array(args[:keys])
-        logger.debug "Verifying '#{list.join(',')}' equals '#{list.empty? ? 'no resources' : list_by_key.join(',')}'."
+        keys = Array(args)
+        logger.debug "Verifying '#{keys.join(',')}' equals '#{list.empty? ? 'no resources' : list_by_key.join(',')}'."
         list.reject {|r| keys.include? r.id}
       end
 

data/lib/outliers/version.rb

@@ -1,3 +1,3 @@
 module Outliers
-  VERSION = "0.3.3"
+  VERSION = "0.5.0.beta1"
 end

data/lib/outliers.rb

@@ -1,12 +1,13 @@
 require "outliers/mixins.rb"
 require "outliers/verifications"
 
+require "outliers/account"
 require "outliers/collection"
-require "outliers/credentials"
 require "outliers/info"
 require "outliers/exceptions"
 require "outliers/evaluation"
 require "outliers/filters"
+require "outliers/handlers"
 require "outliers/provider"
 require "outliers/providers"
 require "outliers/resource"

data/outliers.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["brett@weav.net"]
   spec.description   = %q{Configuraiton verification framework.}
   spec.summary       = %q{Configuration verification framework.}
-  spec.homepage      = "https://github.com/brettweavnet/outliers"
+  spec.homepage      = "http://www.getoutliers.com/documentation"
   spec.license       = "Apache2"
 
   spec.files         = `git ls-files`.split($/)

data/reference.yaml

@@ -1,5 +1,5 @@
 aws_cloud_formation:
-  credentials:
+  account:
     access_key_id: AWS Account Access Key
     secret_access_key: AWS Account Secret Key
     region: AWS Region
@@ -10,7 +10,7 @@ aws_cloud_formation:
       verifications: {}
 
 aws_ec2:
-  credentials:
+  account:
     access_key_id: AWS Account Access Key
     secret_access_key: AWS Account Secret Key
     region: AWS Region
@@ -30,7 +30,7 @@ aws_ec2:
           description: Instance status is running.
         valid_image_id:
           description: ami_ids=ami_id1,ami_id2 - Instances Image ID (AMI) is in given list.
-          args: 'image_ids: [IMAGE_ID1, IMAGEID2]'
+          args: '[IMAGE_ID1, IMAGEID2]'
         vpc:
           description: Instance is in a VPC.
     security_group:
@@ -45,7 +45,7 @@ aws_ec2:
       verifications: {}
 
 aws_elb:
-  credentials:
+  account:
     access_key_id: AWS Account Access Key
     secret_access_key: AWS Account Secret Key
     region: AWS Region
@@ -56,10 +56,10 @@ aws_elb:
       verifications:
         ssl_certificates_valid:
           description: Validates all SSL certificates associated with an ELB are valid for given number of days.
-          args: 'days: DAYS'
+          args: 'DAYS'
 
 aws_iam:
-  credentials:
+  account:
     access_key_id: AWS Account Access Key
     secret_access_key: AWS Account Secret Key
     region: AWS Region
@@ -76,7 +76,7 @@ aws_iam:
           description: Verify password not set for user.
 
 aws_rds:
-  credentials:
+  account:
     access_key_id: AWS Account Access Key
     secret_access_key: AWS Account Secret Key
     region: AWS Region
@@ -87,7 +87,7 @@ aws_rds:
       verifications:
         backup_retention_period:
           description: Validate the backup retention period equals given days for the db_instance.
-          args: 'days: DAYS'
+          args: 'DAYS'
         multi_az:
           description: RDS Multi AZ set to yes.
     db_snapshot:
@@ -96,7 +96,7 @@ aws_rds:
       verifications: {}
 
 aws_s3:
-  credentials:
+  account:
     access_key_id: AWS Account Access Key
     secret_access_key: AWS Account Secret Key
     region: AWS Region
@@ -115,7 +115,7 @@ aws_s3:
           description: Bucket is not configured as a website.
 
 aws_sqs:
-  credentials:
+  account:
     access_key_id: AWS Account Access Key
     secret_access_key: AWS Account Secret Key
     region: AWS Region

data/shared.yaml

@@ -3,4 +3,4 @@ verifications:
     description: No resources exist.
   equals:
     description: Verify the list of resource mataches the given list of keys.
-    args: 'keys: [RESOURCE_ID1, RESOURCE_ID2]'
+    args: '[RESOURCE_ID1, RESOURCE_ID2]'

data/spec/{credentials_spec.rb → account_spec.rb}

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
-describe Outliers::Credentials do
-  subject { Outliers::Credentials }
-  let(:credentials1) { fixture_file 'credentials1.yml' }
-  let(:credentials2) { fixture_file 'credentials2.yml' }
+describe Outliers::Account do
+  subject { Outliers::Account }
+  let(:account1) { fixture_file 'account1.yml' }
+  let(:account2) { fixture_file 'account2.yml' }
 
   context "#load_from_file" do
-    it "should load the credentials from the given yaml file" do
-      File.should_receive(:read).with('/home/user/outliers.yml').and_return credentials1
-      results = { "test_credentials_1" => 
+    it "should load the account from the given yaml file" do
+      File.should_receive(:read).with('/home/user/outliers.yml').and_return account1
+      results = { "test_account_1" => 
                   { "region"            => "us-west-1",
                     "provider"          => "aws_ec2", 
                     "access_key_id"     => "01234567890123456789",

data/spec/collection_spec.rb

@@ -4,6 +4,7 @@ describe Outliers::Collection do
   let(:provider) { mock 'provider' }
   let(:resource1) { mock 'resource1' }
   let(:resource2) { mock 'resource2' }
+  let(:resource3) { mock 'resource3' }
 
   subject { Outliers::Collection.new provider }
 
@@ -12,7 +13,7 @@ describe Outliers::Collection do
     resource1.stub name: 'resource1', key: 'name', id: 'resource1'
     resource2.stub name: 'resource2', key: 'name', id: 'resource2'
     subject.stub :load_all => [resource1, resource2],
-                 :class => Outliers::Resources::Aws::Ec2::SecurityGroupCollection
+                 :class    => Outliers::Resources::Aws::Ec2::SecurityGroupCollection
   end
 
   context "#to_human" do
@@ -36,16 +37,56 @@ describe Outliers::Collection do
   end
 
   context "#filter" do
-    it "should apply the given filter to resources" do
+    before do
+      subject.instance_variable_set(:@list, [resource1, resource2, resource3])
+    end
+
+    it "should include resources matched by include filter" do
       subject.should_receive('filter_tag').with('Name:test123').and_return [resource1]
-      subject.filter 'tag' => 'Name:test123'
+      subject.filter 'include', tag: 'Name:test123'
       expect(subject.list).to eq([resource1])
     end
 
+    it "should exclude resources matched by exclude filter" do
+      subject.should_receive('filter_tag').with('Name:test123').and_return [resource1]
+      subject.filter 'exclude', tag: 'Name:test123'
+      expect(subject.list).to eq([resource2, resource3])
+    end
+
+    it "should apply multiple exclude filters" do
+      subject.should_receive('filter_tag').with('Name:test123').and_return [resource1]
+      subject.should_receive('filter_tag').with('Name:test321').and_return [resource2]
+      subject.filter 'exclude', tag: 'Name:test123'
+      subject.filter 'exclude', tag: 'Name:test321'
+      expect(subject.list).to eq([resource3])
+    end
+
+    it "should apply multiple include filters and only return the union" do
+      subject.should_receive('filter_tag').with('Name:test123').and_return [resource1, resource3]
+      subject.should_receive('filter_tag').with('Name:test321').and_return [resource2, resource3]
+      subject.filter 'include', tag: 'Name:test123'
+      subject.filter 'include', tag: 'Name:test321'
+      expect(subject.list).to eq([resource3])
+    end
+
+    it "should apply exclude and include filters and only return the union" do
+      subject.should_receive('filter_tag').with('Name:test123').and_return [resource1, resource3]
+      subject.should_receive('filter_tag').with('Name:test321').and_return [resource1, resource2]
+      subject.filter 'include', tag: 'Name:test123'
+      subject.filter 'exclude', tag: 'Name:test321'
+      expect(subject.list).to eq([resource3])
+    end
+
     it "should raise an exception if the filter does not exist" do
-      expect { subject.filter('bogus' => 'Name:test123') }.
+      expect { subject.filter('include', 'bogus' => 'Name:test123') }.
         to raise_error Outliers::Exceptions::UnknownFilter
     end
+
+    it "should raise an exception if the filter action does not exist" do
+      subject.should_receive('filter_tag').with('Name:test123').and_return [resource1]
+      expect { subject.filter('bad_action', 'tag' => 'Name:test123') }.
+        to raise_error Outliers::Exceptions::UnknownFilterAction
+    end
   end
 
   context "#key" do
@@ -72,16 +113,16 @@ describe Outliers::Collection do
     end
 
     it "should verify the given verification against the colection" do
-      expect(subject.verify 'none_exist?', {}).
+      expect(subject.verify 'none_exist?').
         to eq( { failing_resources: [resource1, resource2], passing_resources: [] } )
     end
 
     it "should raise unkown verification if the verification does not exist" do
-      expect { subject.verify 'none', {} }.to raise_error Outliers::Exceptions::UnknownVerification
+      expect { subject.verify 'none' }.to raise_error Outliers::Exceptions::UnknownVerification
     end
 
     it "should verify the given verification against the colection with options" do
-      expect(subject.verify 'equals?', :keys => ['resource1', 'resource2']).
+      expect(subject.verify 'equals?', ['resource1', 'resource2']).
         to eq( { failing_resources: [], passing_resources: [resource1, resource2] } )
     end
 

data/spec/evaluation_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe Outliers::Evaluation do
   let(:run) { mock 'run' }
-  let(:connect) { subject.connect('test_credentials_1') }
+  let(:connect) { subject.connect('test_account_1') }
   let(:resources) { subject.resources('security_group') }
   subject { Outliers::Evaluation.new :run => run, :name => 'test' }
 
   before do
     stub_logger
-    run.stub :credentials => credentials
+    run.stub :account => account
   end
 
   context "#connect" do
@@ -18,20 +18,21 @@ describe Outliers::Evaluation do
     end
 
     it "should connect to the provider specified as an option" do
-      subject.connect('test_credentials_1', { 'provider' => 'aws_rds' })
+      subject.connect('test_account_1', { 'provider' => 'aws_rds' })
       expect(subject.provider_name_array).to eq(['Aws', 'Rds'])
     end
 
     it "should throw an error if the provider if the provider class is unkown" do
-      expect { subject.connect('test_credentials_1', { 'provider' => 'bad_provider' }) }.
+      expect { subject.connect('test_account_1', { 'provider' => 'bad_provider' }) }.
         to raise_error(Outliers::Exceptions::UnknownProvider)
     end
 
     it "should override a valid provider with one provided" do
-      subject.connect('test_credentials_1', { 'provider' => 'aws_ec2' })
+      subject.connect('test_account_1', { 'provider' => 'aws_ec2' })
       expect(subject.provider_name_array).to eq(['Aws', 'Ec2'])
     end
   end
+    
 
   context "with connection and resources" do 
     before do
@@ -41,9 +42,9 @@ describe Outliers::Evaluation do
 
     context "#resources" do
       it "should assign the collection_object" do
-        expect(subject.collection.class).
+        expect(subject.resource_collection.class).
           to eq(Outliers::Resources::Aws::Ec2::SecurityGroupCollection)
-        expect(subject.collection.provider.class).
+        expect(subject.resource_collection.provider.class).
           to eq(Outliers::Providers::Aws::Ec2)
       end
 
@@ -53,40 +54,71 @@ describe Outliers::Evaluation do
       end
 
       it "should test that over ride options are applied when selecting colleciton" do
-        subject.connect('test_credentials_1', :provider => 'aws_rds')
+        subject.connect('test_account_1', :provider => 'aws_rds')
         subject.resources('db_instance')
-        expect(subject.collection.provider.class).
+        expect(subject.resource_collection.provider.class).
           to eq(Outliers::Providers::Aws::Rds)
       end
 
-      it "should set the collection targets if specified" do
-        subject.connect('test_credentials_1', :provider => 'aws_rds')
-        expect(subject.resources('db_instance', 'instance-123').targets).to eq ['instance-123']
-      end
-    end
-
-    context "#exclude" do
-      it "should convert input to array and send call exclude_by_key with value" do
-        resources.should_receive(:exclude_by_key).with(['test'])
-        subject.exclude 'test'
+      context "testing resource assignment" do
+        before do
+          subject.connect('test_account_1', :provider => 'aws_rds')
+        end
+
+        it "should set the collection targets if specified" do
+          subject.resources('db_instance', include: 'instance-123')
+          expect(subject.resource_collection.targets).to eq ['instance-123']
+        end
+
+        it "should send call exclude_by_key with given array" do
+          Outliers::Resources::Aws::Rds::DbInstanceCollection.
+            any_instance.should_receive(:exclude_by_key).with(['instance-123', 'instance-321'])
+          subject.resources('db_instance', exclude: ['instance-123', 'instance-321'])
+        end
+
+        it "should convert input to array and send call exclude_by_key with value" do
+          Outliers::Resources::Aws::Rds::DbInstanceCollection.
+            any_instance.should_receive(:exclude_by_key).with(['instance-123'])
+          subject.resources('db_instance', exclude: 'instance-123')
+        end
+
+        it "should include the given string as array" do
+          subject.resources('db_instance', include: 'instance-123')
+          expect(subject.resource_collection.targets).to eq ['instance-123']
+        end
+
+        it "should include the array from the include key" do
+          subject.resources('db_instance', include: ['instance-123', 'instance-321'])
+          expect(subject.resource_collection.targets).to eq ['instance-123', 'instance-321']
+        end
+
+        it "should include the array" do
+          subject.resources('db_instance', ['instance-123', 'instance-321'])
+          expect(subject.resource_collection.targets).to eq ['instance-123', 'instance-321']
+        end
+
+        it "should include the string" do
+          subject.resources('db_instance', 'instance-123')
+          expect(subject.resource_collection.targets).to eq ['instance-123']
+        end
       end
     end
 
     context "#filter" do
       it "should apply the given filter to the collection" do
-        resources.should_receive(:filter).with('tag' => 'Name:test123')
-        subject.filter 'tag' => 'Name:test123'
+        resources.should_receive(:filter).with('include', 'tag' => 'Name:test123')
+        subject.filter 'include', 'tag' => 'Name:test123'
       end
 
       it "should convert keys in the args hash to strings" do
-        resources.should_receive(:filter).with('tag' => 'Name:test123')
-        subject.filter tag: 'Name:test123'
+        resources.should_receive(:filter).with('include', 'tag' => 'Name:test123')
+        subject.filter 'include', tag: 'Name:test123'
       end
     end
 
     context "#verify" do
-      let(:result1) { mock 'result1' }
-      let(:result2) { mock 'result2' }
+      let(:result1) { stub 'result1', :passed? => true }
+      let(:result2) { stub 'result2', :passed? => true }
       let(:verification_response) { ( { passing_resources: ['1', '2'], failing_resources: ['3', '4'] } ) }
 
       before do
@@ -95,40 +127,70 @@ describe Outliers::Evaluation do
       end
 
       it "should verify the given method" do
-        resources.should_receive(:verify).with('test_verification?', {}).and_return verification_response
-        Outliers::Result.should_receive(:new).with(evaluation:        'test',
-                                                   passing_resources: ['1','2'],
+        resources.should_receive(:verify).with('test_verification?', nil).and_return verification_response
+        Outliers::Result.should_receive(:new).with(account_name:      'test_account_1',
+                                                   arguments:         [],
                                                    failing_resources: ['3','4'],
-                                                   resource:          resources,
-                                                   verification:      'test_verification?').and_return result1
-        expect(subject.verify('test_verification?', {})).to eq([result1])
+                                                   name:              'test',
+                                                   passing_resources: ['1','2'],
+                                                   provider_name:     'aws_ec2',
+                                                   resource_name:     'security_group',
+                                                   verification_name: 'test_verification?').and_return result1
+        expect(subject.verify('test_verification?')).to eq([result1])
       end
 
       it "should convert all options to symbols" do
-        resources.should_receive(:verify).with('test_verification?', :test => false).and_return verification_response
-        Outliers::Result.should_receive(:new).with(evaluation:        'test',
+        resources.should_receive(:verify).with('test_verification?', ['test123']).and_return verification_response
+        Outliers::Result.should_receive(:new).with(account_name:      'test_account_1',
+                                                   arguments:         ['test123'],
+                                                   failing_resources: ['3','4'],
+                                                   name:              'test',
                                                    passing_resources: ['1','2'],
+                                                   provider_name:     'aws_ec2',
+                                                   resource_name:     'security_group',
+                                                   verification_name: 'test_verification?').and_return result1
+        expect(subject.verify('test_verification?', ['test123'] )).to eq([result1])
+      end
+
+      it "should convert arguments string to array in results" do
+        resources.should_receive(:verify).with('test_verification?', ['arg']).and_return verification_response
+        Outliers::Result.should_receive(:new).with(account_name:      'test_account_1',
+                                                   arguments:         ['arg'],
                                                    failing_resources: ['3','4'],
-                                                   resource:          resources,
-                                                   verification:      'test_verification?').and_return result1
-        expect(subject.verify('test_verification?', { 'test' => false } )).to eq([result1])
+                                                   name:              'test',
+                                                   passing_resources: ['1','2'],
+                                                   provider_name:     'aws_ec2',
+                                                   resource_name:     'security_group',
+                                                   verification_name: 'test_verification?').and_return result1
+        expect(subject.verify('test_verification?', 'arg' )).to eq([result1])
+      end
+
+      it "should raise and error if the arguments are not nil, string or array" do
+        expect { subject.verify('test_verification?', arg: 'bad_arg' ) }.
+          to raise_error(Outliers::Exceptions::InvalidArguments)
       end
 
       it "should run verify multiple times in given evaluation" do
-        resources.should_receive(:verify).with('test_verification1?', :test => false).and_return verification_response
-        resources.should_receive(:verify).with('test_verification2?', :test => true).and_return verification_response
-        Outliers::Result.should_receive(:new).with(evaluation:        'test',
-                                                   passing_resources: ['1','2'],
+        resources.should_receive(:verify).with('test_verification1?', ['arg1']).and_return verification_response
+        resources.should_receive(:verify).with('test_verification2?', ['arg2']).and_return verification_response
+        Outliers::Result.should_receive(:new).with(account_name:      'test_account_1',
+                                                   arguments:         ['arg1'],
                                                    failing_resources: ['3','4'],
-                                                   resource:          resources,
-                                                   verification:      'test_verification1?').and_return result1
-        Outliers::Result.should_receive(:new).with(evaluation:        'test',
+                                                   name:              'test',
                                                    passing_resources: ['1','2'],
+                                                   provider_name:     'aws_ec2',
+                                                   resource_name:     'security_group',
+                                                   verification_name: 'test_verification1?').and_return result1
+        Outliers::Result.should_receive(:new).with(account_name:      'test_account_1',
+                                                   arguments:         ['arg2'],
                                                    failing_resources: ['3','4'],
-                                                   resource:          resources,
-                                                   verification:      'test_verification2?').and_return result2
-        expect(subject.verify('test_verification1?', { 'test' => false })).to eq [result1]
-        expect(subject.verify('test_verification2?', { 'test' => true })).to eq [result1, result2]
+                                                   name:              'test',
+                                                   passing_resources: ['1','2'],
+                                                   provider_name:     'aws_ec2',
+                                                   resource_name:     'security_group',
+                                                   verification_name: 'test_verification2?').and_return result2
+        expect(subject.verify('test_verification1?', ['arg1'])).to eq [result1]
+        expect(subject.verify('test_verification2?', ['arg2'])).to eq [result1, result2]
       end
     end
 

data/spec/fixtures/{credentials1.yml → account1.yml}

@@ -1,4 +1,4 @@
-test_credentials_1:
+test_account_1:
   region: us-west-1
   provider: aws_ec2
   access_key_id: 01234567890123456789