right_infrastructure_agent 1.1.2

data/spec/models_helper_spec.rb

@@ -0,0 +1,546 @@
+# Copyright (c) 2009-2011 RightScale, Inc, All Rights Reserved Worldwide.
+#
+# THIS PROGRAM IS CONFIDENTIAL AND PROPRIETARY TO RIGHTSCALE
+# AND CONSTITUTES A VALUABLE TRADE SECRET.  Any unauthorized use,
+# reproduction, modification, or disclosure of this program is
+# strictly prohibited.  Any use of this program by an authorized
+# licensee is strictly subject to the terms and conditions,
+# including confidentiality obligations, set forth in the applicable
+# License Agreement between RightScale.com, Inc. and
+# the licensee.
+
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe RightScale::ModelsHelper do
+
+  include RightScale::ModelsHelper
+
+  class Account; end
+  class AuditEntry; end
+  class InstanceApiToken; end
+  class Permission; end
+  class Repository; end
+  class RightScript; end
+  class Setting; end
+  class ServerTemplateChefRecipe; end
+  class User; end
+  class UserCredential; end
+
+  before(:each) do
+    flexmock(RightScale::Log).should_receive(:info).never.by_default
+    flexmock(RightScale::Log).should_receive(:warning).never.by_default
+    flexmock(RightScale::Log).should_receive(:error).never.by_default
+    @audit_formatter = flexmock(RightScale::AuditFormatter)
+    @audit_formatter.should_receive(:error).never.by_default
+    @audit = flexmock("audit")
+    @audit.should_receive(:append).never.by_default
+    @last_error = nil
+  end
+
+  context :query do
+    it 'should run query, yielding to block and returning result from query block' do
+      called = 0
+      result = query("query database") { called += 1 }
+      called.should == 1
+      result.should == 1
+    end
+
+    it 'should catch and log exception and return nil by default' do
+      flexmock(RightScale::Log).should_receive(:error).with("Failed to query database", NoMethodError, :trace).once
+      called = 0
+      result = query("query database") do
+        called += 1
+        nil + "string"
+      end
+      called.should == 1
+      result.should == nil
+      error = /Failed to query database \(NoMethodError.*undefined method.*models_helper_spec.*\)$/
+      (@last_error.should =~ error).should be_true
+    end
+
+    it 'should audit exception if audit enabled' do
+      error = /Failed to query database \(NoMethodError.*undefined method.*models_helper_spec.*\)$/
+      @audit_formatter.should_receive(:error).with(error).once
+      @audit.should_receive(:append).once
+      flexmock(RightScale::Log).should_receive(:error).once
+      called = 0
+      result = query("query database", :audit => @audit) do
+        called += 1
+        nil + "string"
+      end
+      called.should == 1
+      result.should == nil
+      (@last_error.should =~ error).should be_true
+    end
+
+    it 'should return nil if catch RecordNotFound exception and not log error' do
+      called = 0
+      result = query("query database") do
+        called += 1
+        raise ActiveRecord::RecordNotFound.new("Missing")
+      end
+      called.should == 1
+      result.should == nil
+      @last_error.should be_nil
+    end
+
+    it 'should raise RetryableError if exceed retries, :retryable_error enabled, and error retryable' do
+      flexmock(RightScale::Log).should_receive(:info).with("Retrying query...").times(3)
+      flexmock(RightScale::Log).should_receive(:warning).with("Aborting query after 3 failed retries").once
+      flexmock(RightScale::Log).should_receive(:error).with("Failed running MySQL query",
+                                                            ActiveRecord::StatementInvalid, :trace).times(3)
+      flexmock(RightScale::Log).should_receive(:error).with("Failed to query database but retryable",
+                                                            RightScale::Exceptions::RetryableError, :trace).once
+      lambda do
+        query("query database", :retryable_error => true) do
+          raise ActiveRecord::StatementInvalid.new("Deadlock found")
+        end
+      end.should raise_error(RightScale::Exceptions::RetryableError)
+      error = /Failed to query database but retryable \(RightScale::Exceptions::RetryableError: RightScale database temporarily unavailable in .*models_helper.*\)$/
+      (@last_error.should =~ error).should be_true
+    end
+
+    it 'should not raise RetryableError if exceed retries, :retryable_error enabled, but error not retryable' do
+      flexmock(RightScale::Log).should_receive(:info).with("Retrying query...").times(3)
+      flexmock(RightScale::Log).should_receive(:warning).with("Aborting query after 3 failed retries").once
+      flexmock(RightScale::Log).should_receive(:error).with("Failed running MySQL query",
+                                                            ActiveRecord::StatementInvalid, :trace).times(3)
+      flexmock(RightScale::Log).should_receive(:error).with("Failed to query database",
+                                                            ActiveRecord::StatementInvalid, :trace).once
+      query("query database", :retryable_error => true) do
+        raise ActiveRecord::StatementInvalid.new("Invalid query")
+      end
+      error = /Failed to query database \(ActiveRecord::StatementInvalid.*Invalid query in .*models_helper_spec.*\)$/
+      (@last_error.should =~ error).should be_true
+    end
+  end
+
+  context :run_query do
+    it 'should return result of executed block' do
+      run_query { "result" }.should == "result"
+    end
+
+    it 'should treat RecordNotFound as nil result and not raise error' do
+      run_query { raise ActiveRecord::RecordNotFound }.should be_nil
+    end
+
+    it 'should retry if exception is retryable' do
+      flexmock(RightScale::Log).should_receive(:info).with("Retrying query...").once
+      flexmock(RightScale::Log).should_receive(:error).with("Failed running MySQL query",
+                                                            ActiveRecord::StatementInvalid, :trace).once
+      called = 0
+      result = run_query do
+        called += 1
+        raise ActiveRecord::StatementInvalid.new("Invalid query") if called == 1
+        "result"
+      end
+      called.should == 2
+      result.should == "result"
+    end
+
+    it 'should raise exception if not retryable' do
+      flexmock(RightScale::Log).should_receive(:info).with("Retrying query...").never
+      lambda do
+        run_query do
+          raise ArgumentError
+        end
+      end.should raise_error(ArgumentError)
+    end
+
+    it 'should retry at most 3 times' do
+      flexmock(RightScale::Log).should_receive(:info).with("Retrying query...").times(3)
+      flexmock(RightScale::Log).should_receive(:warning).with("Aborting query after 3 failed retries").once
+      flexmock(RightScale::Log).should_receive(:error).with("Failed running MySQL query",
+                                                            ActiveRecord::StatementInvalid, :trace).times(3)
+      called = 0
+      lambda do
+        run_query do
+          called += 1
+          raise ActiveRecord::StatementInvalid.new("Invalid query")
+        end
+      end.should raise_error(ActiveRecord::StatementInvalid)
+      called.should == 4
+    end
+
+    it 'should raise RetryableError if exceed retries, :retryable_error enabled, and error retryable' do
+      flexmock(RightScale::Log).should_receive(:info).with("Retrying query...").times(3)
+      flexmock(RightScale::Log).should_receive(:warning).with("Aborting query after 3 failed retries").once
+      flexmock(RightScale::Log).should_receive(:error).with("Failed running MySQL query",
+                                                            ActiveRecord::StatementInvalid, :trace).times(3)
+      called = 0
+      lambda do
+        run_query(:retryable_error => true) do
+          called += 1
+          raise ActiveRecord::StatementInvalid.new("Deadlock found")
+        end
+      end.should raise_error(RightScale::Exceptions::RetryableError, RightScale::ModelsHelper::DEFAULT_RETRY_MESSAGE)
+      called.should == 4
+    end
+
+    it 'should raise RetryableError with account unavailable message if wrong shard error' do
+      flexmock(RightScale::Log).should_receive(:info).with("Retrying query...").times(3)
+      flexmock(RightScale::Log).should_receive(:warning).with("Aborting query after 3 failed retries").once
+      flexmock(RightScale::Log).should_receive(:error).with("Failed running MySQL query",
+                                                            ActiveRecord::StatementInvalid, :trace).times(3)
+      called = 0
+      lambda do
+        run_query(:retryable_error => true) do
+          called += 1
+          raise ActiveRecord::StatementInvalid.new(RightScale::ModelsHelper::WRONG_SHARD_ERROR)
+        end
+      end.should raise_error(RightScale::Exceptions::RetryableError, RightScale::ModelsHelper::WRONG_SHARD_RETRY_MESSAGE)
+      called.should == 4
+    end
+
+    it 'should not raise RetryableError if exceed retries, :retryable_error enabled, but error not retryable' do
+      flexmock(RightScale::Log).should_receive(:info).with("Retrying query...").times(3)
+      flexmock(RightScale::Log).should_receive(:warning).with("Aborting query after 3 failed retries").once
+      flexmock(RightScale::Log).should_receive(:error).with("Failed running MySQL query",
+                                                            ActiveRecord::StatementInvalid, :trace).times(3)
+      called = 0
+      lambda do
+        run_query(:retryable_error => true) do
+          called += 1
+          raise ActiveRecord::StatementInvalid.new("Invalid query")
+        end
+      end.should raise_error(ActiveRecord::StatementInvalid)
+      called.should == 4
+    end
+  end
+
+  context :is_retryable_error? do
+    it 'should be permissive of any MysqlError or ActiveRecord::ActiveRecordError for local test' do
+      is_retryable_error?(ArgumentError.new("anything"), local = true).should be_false
+      is_retryable_error?(MysqlError.new("anything"), local = true).should be_true
+      is_retryable_error?(MysqlError.new("has gone away"), local = true).should be_true
+      is_retryable_error?(ActiveRecord::StatementInvalid.new("anything"), local = true).should be_true
+      is_retryable_error?(ActiveRecord::StatementInvalid.new("Deadlock found"), local = true).should be_true
+    end
+
+    it 'should use selected ActiveRecord::ActiveRecordError retryable errors to restrict for external test' do
+      is_retryable_error?(ArgumentError.new("anything")).should be_false
+      is_retryable_error?(MysqlError.new("anything")).should be_false
+      is_retryable_error?(MysqlError.new("has gone away")).should be_true
+      is_retryable_error?(ActiveRecord::StatementInvalid.new("anything")).should be_false
+      is_retryable_error?(ActiveRecord::StatementInvalid.new("Deadlock found")).should be_true
+    end
+  end
+
+  context :retrieve_or_create_audit do
+    it 'should retrieve audit when id specified' do
+      flexmock(self).should_receive(:audit_entry).with(123, :audit_id => 123).and_return("audit")
+      flexmock(AuditEntry).should_receive(:create!).never
+      retrieve_or_create_audit("instance", "summary", "detail", "account", "user", :audit_id => 123).should == "audit"
+    end
+
+    it 'should create audit when agent identity specified instead of id' do
+      flexmock(self).should_receive(:audit_entry).with(1, :audit_id => 123).never
+      flexmock(AuditEntry).should_receive(:create!).with({:auditee => "instance", :summary => "summary", :detail => "detail",
+                                                          :account => "account", :user => "user"}).and_return("audit").once
+      retrieve_or_create_audit("instance", "summary", "detail", "account", "user", :agent_identity => "111").should == "audit"
+
+    end
+
+    it 'should raise exception if neiher audit id or agent identity specified' do
+      lambda do
+        retrieve_or_create_audit("instance", "summary", "detail", "account", "user")
+      end.should raise_error(ArgumentError)
+    end
+  end
+
+  context :retrieve_or_default_user do
+    before(:each) do
+      @user = flexmock("user", :id= => 0, :id => 123)
+      @account = flexmock("account", :users => [@user])
+      @instance = flexmock("instance", :account => @account)
+    end
+
+    it 'should return default user if not user id supplied' do
+      flexmock(User).should_receive(:new).with(:email => "alerter@rightscale.com").and_return(@user).once
+      retrieve_or_default_user(@instance).should == @user
+    end
+
+    it 'should retrieve user if user id supplied' do
+      flexmock(User).should_receive(:new).never
+      result = retrieve_or_default_user(@instance, :user_id => 123).should == @user
+    end
+
+    it 'should return error result if no user found' do
+      retrieve_or_default_user(@instance, :user_id => 124).should be_nil
+    end
+  end
+
+  context :retrieve do
+    it 'should yield and return result from block' do
+      called = 0
+      result = retrieve("something") { called += 1 }
+      called.should == 1
+      result.should == 1
+      @last_error.should be_nil
+    end
+
+    it 'should detect not found but not log warning nor audit by default' do
+      called = 0
+      result = retrieve("something") { called += 1; nil }
+      called.should == 1
+      result.should == nil
+      @last_error.should == "Could not find something"
+    end
+
+    it 'should detect not found and log warning if log enabled' do
+      flexmock(RightScale::Log).should_receive(:warning).with(/Could not find something/).once
+      called = 0
+      result = retrieve("something", :log => true) { called += 1; nil }
+      called.should == 1
+      result.should == nil
+      @last_error.should == "Could not find something"
+    end
+
+    it 'should detect not found and audit if audit enabled' do
+      @audit_formatter.should_receive(:error).with("Could not find something").once
+      @audit.should_receive(:append).once
+      called = 0
+      result = retrieve("something", :audit => @audit) { called += 1; nil }
+      called.should == 1
+      result.should == nil
+      @last_error.should == "Could not find something"
+    end
+
+    it 'should catch and log exception and return nil by default' do
+      flexmock(RightScale::Log).should_receive(:error).with("Failed to retrieve something", NoMethodError, :trace).once
+      called = 0
+      result = retrieve("something") do
+        called += 1
+        nil + "string"
+      end
+      called.should == 1
+      result.should == nil
+      error = /Failed to retrieve something \(NoMethodError.*undefined method.*models_helper_spec.*\)$/
+      (@last_error.should =~ error).should be_true
+    end
+
+    it 'should audit exception if audit enabled' do
+      error = /Failed to retrieve something \(NoMethodError.*undefined method.*models_helper_spec.*\)$/
+      @audit_formatter.should_receive(:error).with(error).once
+      @audit.should_receive(:append).once
+      flexmock(RightScale::Log).should_receive(:error).once
+      called = 0
+      result = retrieve("something", :audit => @audit) do
+        called += 1
+        nil + "string"
+      end
+      called.should == 1
+      result.should == nil
+      (@last_error.should =~ error).should be_true
+    end
+
+    it 'should not log or audit an error from a previous retrieval' do
+      called = 0
+      result = retrieve("something") { called += 1; nil }
+      called.should == 1
+      result.should == nil
+      @last_error.should == "Could not find something"
+      result = retrieve("something else", :audit => true, :log => true) { called += 1 }
+      called.should == 2
+      @last_error.should be_nil
+    end
+  end
+
+  context :instance_token do
+    it 'should retrieve InstanceApiToken using id' do
+      flexmock(InstanceApiToken).should_receive(:find).with(123).and_return("instance_api_token").once
+      instance_token(123).should == "instance_api_token"
+    end
+  end
+
+  context :instance do
+    before(:each) do
+      @token_id = 123
+      @account = flexmock("account")
+      @account.should_receive(:disabled_in_every_shard?).and_return(false).by_default
+      @instance = flexmock("instance", :account => @account)
+      @instance_api_token = flexmock("instance_api_token")
+      @instance_api_token.should_receive(:instance).and_return(@instance)
+      flexmock(InstanceApiToken).should_receive(:find).with(@token_id).and_return(@instance_api_token).once
+    end
+
+    it 'should retrieve Instance using id' do
+      instance(@token_id).should == @instance
+    end
+
+    it 'should raise RetryableError if shard is disabled for account' do
+      @account.should_receive(:disabled_in_every_shard?).and_return(true)
+      lambda do
+        instance(@token_id)
+      end.should raise_error(RightScale::Exceptions::RetryableError)
+    end
+  end
+
+  context :instance_from_token_id do
+    before(:each) do
+      @token_id = 123
+      @account = flexmock("account")
+      @account.should_receive(:disabled_in_every_shard?).and_return(false).by_default
+      @instance = flexmock("instance", :account => @account)
+      @instance_api_token = flexmock("instance_api_token")
+      @instance_api_token.should_receive(:instance).and_return(@instance).by_default
+      flexmock(InstanceApiToken).should_receive(:find).with(@token_id).and_return(@instance_api_token).by_default
+    end
+
+    it 'should retrieve Instance using token_id' do
+      instance_from_token_id(@token_id).should == @instance
+    end
+
+    it 'should cache tokens and use to reload instance' do
+      @instance.should_receive(:reload).and_return(@instance).once
+      instance_from_token_id(@token_id).should == @instance
+      @tokens[@token_id].should == @instance
+      instance_from_token_id(@token_id).should == @instance
+    end
+
+    it 'should raise exception if InstanceApiToken not found' do
+      flexmock(InstanceApiToken).should_receive(:find).with(@token_id).and_return(nil)
+      lambda do
+        instance_from_token_id(@token_id).should == @instance
+      end.should raise_error(RightScale::Exceptions::Application)
+    end
+
+    it 'should raise exception if Instance not found' do
+      @instance_api_token.should_receive(:instance).and_return(nil)
+      lambda do
+        instance_from_token_id(@token_id).should == @instance
+      end.should raise_error(RightScale::Exceptions::Application)
+    end
+
+    it 'should raise RetryableError if shard is disabled for account' do
+      @account.should_receive(:disabled_in_every_shard?).and_return(true)
+      lambda do
+        instance_from_token_id(@token_id)
+      end.should raise_error(RightScale::Exceptions::RetryableError)
+    end
+  end
+
+  context :instance_from_agent_id do
+    before(:each) do
+      @token_id = 123
+      @agent_id = "rs-instance-1111-#{@token_id}"
+      @account = flexmock("account")
+      @account.should_receive(:disabled_in_every_shard?).and_return(false).by_default
+      @instance = flexmock("instance", :account => @account)
+      @instance_api_token = flexmock("instance_api_token")
+      @instance_api_token.should_receive(:instance).and_return(@instance).by_default
+      flexmock(InstanceApiToken).should_receive(:find).with(@token_id).and_return(@instance_api_token).by_default
+    end
+
+    it 'should retrieve Instance using agent identity' do
+      instance_from_agent_id(@agent_id).should == @instance
+    end
+
+    it 'should raise error if agent identity invalid' do
+      lambda do
+        instance_from_agent_id("rs-instance-1111")
+      end.should raise_error(ArgumentError)
+    end
+
+    it 'should raise RetryableError if shard is disabled for account' do
+      @account.should_receive(:disabled_in_every_shard?).and_return(true)
+      lambda do
+        instance_from_agent_id(@agent_id)
+      end.should raise_error(RightScale::Exceptions::RetryableError)
+    end
+  end
+
+  context :account do
+    it 'should retrieve Account using id' do
+      flexmock(Account).should_receive(:find).with(123).and_return("account").once
+      account(123).should == "account"
+    end
+  end
+
+  context :audit_entry do
+    it 'should retrieve AuditEntry using id' do
+      flexmock(AuditEntry).should_receive(:find).with(123).and_return("audit_entry").once
+      audit_entry(123).should == "audit_entry"
+    end
+  end
+
+  context :right_script do
+    it 'should retrieve RightScript using id' do
+      flexmock(RightScript).should_receive(:find).with(123).and_return("right_script").once
+      right_script(123).should == "right_script"
+    end
+  end
+
+  context :right_script_from_name do
+    it 'should retrieve RightScript using name' do
+      right_scripts = flexmock("right_scripts")
+      right_scripts.should_receive(:find_by_name).with("name").and_return("script")
+      server_template = flexmock("server_template", :right_scripts => right_scripts)
+      instance = flexmock("instance", :server_template => server_template)
+      right_script_from_name("name", instance).should == "script"
+    end
+
+    it 'should not retrieve RightScript if instance has no server template' do
+      instance = flexmock("instance", :server_template => nil)
+      right_script_from_name("name", instance).should be_nil
+    end
+  end
+
+  context :recipe do
+    it 'should retrieve ServerTemplateChefRecipe using id' do
+      flexmock(ServerTemplateChefRecipe).should_receive(:find).with(123).and_return("recipe").once
+      recipe(123).should == "recipe"
+    end
+  end
+
+  context :recipe_from_name do
+    it 'should retrieve ServerTemplateChefRecipe using name' do
+      server_template_chef_recipes = flexmock("server_template_chef_recipes")
+      server_template_chef_recipes.should_receive(:find_by_recipe).with("name").and_return("recipe")
+      server_template = flexmock("server_template", :server_template_chef_recipes => server_template_chef_recipes)
+      instance = flexmock("instance", :server_template => server_template)
+      recipe_from_name("name", instance).should == "recipe"
+    end
+
+    it 'should not retrieve ServerTemplateChefRecipe if instance has no server template' do
+      instance = flexmock("instance", :server_template => nil)
+      recipe_from_name("name", instance).should be_nil
+    end
+  end
+
+  context :permission do
+    it 'should retrieve Permission using id' do
+      flexmock(Permission).should_receive(:find).with(123).and_return("permission").once
+      permission(123).should == "permission"
+    end
+  end
+
+  context :user_credential do
+    it 'should retrieve UserCredential using id' do
+      flexmock(UserCredential).should_receive(:find).with(123).and_return("user_credential").once
+      user_credential(123).should == "user_credential"
+    end
+  end
+
+  context :user_credential_from_fingerprint do
+    it 'should retrieve UserCredential using fingerprint' do
+      flexmock(UserCredential).should_receive(:find_by_public_value_fingerprint).with("123").and_return("user_credential").once
+      user_credential_from_fingerprint("123").should == "user_credential"
+    end
+  end
+
+  context :setting do
+    it 'should retrieve Setting using id' do
+      flexmock(Setting).should_receive(:find).with(123).and_return("setting").once
+      setting(123).should == "setting"
+    end
+  end
+
+  context :repositories do
+    it 'should retrieve all Repository objects' do
+      flexmock(Repository).should_receive(:find).with(:all).and_return("repositories").once
+      repositories.should == "repositories"
+    end
+  end
+
+end