right_agent 2.0.7-x86-mingw32

data/spec/agent_tag_manager_spec.rb

@@ -0,0 +1,319 @@
+#
+# Copyright (c) 2013 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe RightScale::AgentTagManager do
+
+  include FlexMock::ArgumentTypes
+
+  before(:each) do
+    @log = flexmock(RightScale::Log)
+    @log.should_receive(:error).by_default.and_return { |m| raise RightScale::Log.format(*m) }
+    @identity = "rs-agent-1-1"
+    @agent_href = "/api/clouds/1/instances/1"
+    @agent_href2 = "/api/clouds/2/instances/2"
+    @agent = flexmock("agent", :self_href => @agent_href, :identity => @identity)
+    @hrefs = [@agent_href, @agent_href2]
+    @manager = RightScale::AgentTagManager.instance
+    @manager.agent = @agent
+    @request = flexmock("request", :run => true)
+    @request.should_receive(:callback).and_yield("result").by_default
+    @request.should_receive(:errback).by_default
+    @request.should_receive(:raw_response).and_return("raw response").by_default
+    @retryable_request = flexmock(RightScale::RetryableRequest)
+    @tag = "some:tag=value"
+    @tag1 = "other:tag=value"
+    @tags = [@tag, @tag1]
+    @result = nil
+  end
+
+  context :tags do
+
+    before(:each) do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :hrefs => [@agent_href]}, {}).and_return(@request).once.by_default
+    end
+
+    it "retrieves current agent tags" do
+      @request.should_receive(:callback).and_yield({@agent_href => {"tags" => [@tag]}}).once
+      @manager.tags { |r| @result = r }
+      @result.should == [@tag]
+    end
+
+    it "returns empty array when there is no results hash" do
+      @request.should_receive(:callback).and_yield({}).once
+      @manager.tags { |r| @result = r }
+      @result.should == []
+    end
+
+    it "returns the raw result when result is not a hash" do
+      @request.should_receive(:callback).and_yield("result").once
+      @manager.tags { |r| @result = r }
+      @result.should == "result"
+    end
+
+    it "returns raw result when :raw option specified" do
+      @request.should_receive(:callback).and_yield("result").once
+      @request.should_receive(:raw_response).and_return("raw response").once
+      @manager.tags(:raw => true) { |r| @result = r }
+      @result.should == "raw response"
+    end
+
+    it "forwards timeout option" do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :hrefs => [@agent_href]}, {:timeout => 9}).and_return(@request).once
+      @request.should_receive(:callback).and_yield({@agent_href => {"tags" => [@tag]}}).once
+      @manager.tags(:timeout => 9) { |r| @result = r }
+      @result.should == [@tag]
+    end
+
+    it "yields error result and logs error" do
+      @log.should_receive(:error).with(/Failed to query tags/).once
+      @request.should_receive(:errback).and_yield("error").once
+      @request.should_receive(:callback).once
+      @manager.tags { |r| @result = r }
+      @result.should == "error"
+    end
+  end
+
+  context :query_tags do
+
+    it "queries for agents having individual tag" do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :tags => [@tag]}, {}).and_return(@request).once
+      @request.should_receive(:callback).and_yield({@identity => {"tags" => [@tag]}, @agent_href => {"tags" => [@tag]}}).once
+      @manager.query_tags(@tag) { |r| @result = r }
+      @result.should == {@identity => {"tags" => [@tag]}, @agent_href => {"tags" => [@tag]}}
+    end
+
+    it "queries for agents having multiple tags" do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :tags => @tags}, {}).and_return(@request).once
+      @request.should_receive(:callback).and_yield({@agent_href => {"tags" => @tags}}).once
+      @manager.query_tags(@tags) { |r| @result = r }
+      @result.should == {@agent_href => {"tags" => @tags}}
+    end
+
+    it "forwards options" do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :tags => @tags}, {:timeout => 9}).and_return(@request).once
+      @request.should_receive(:callback).and_yield({@identity => {"tags" => [@tag]}}).once
+      @request.should_receive(:raw_response).and_return("raw response").once
+      @manager.query_tags(@tags, :raw => true, :timeout => 9) { |r| @result = r }
+      @result.should == "raw response"
+    end
+
+    it "yields error result and logs error" do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :tags => [@tag]}, {}).and_return(@request).once
+      @log.should_receive(:error).with(/Failed to query tags/).once
+      @request.should_receive(:errback).and_yield("error").once
+      @request.should_receive(:callback).once
+      @manager.query_tags(@tag) { |r| @result = r }
+      @result.should == "error"
+    end
+  end
+
+  context :query_tags_raw do
+
+    before(:each) do
+      @request.should_receive(:raw_response).and_return("raw response").once
+    end
+
+    it "always yields raw response" do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :tags => [@tag]}, {}).and_return(@request).once
+      @request.should_receive(:callback).and_yield({@identity => {"tags" => [@tag]}, @agent_href => {"tags" => [@tag]}}).once
+      @manager.query_tags_raw(@tag) { |r| @result = r }
+      @result.should == "raw response"
+    end
+
+    it "queries for agents having individual tag and always yields raw response" do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :tags => [@tag]}, {}).and_return(@request).once
+      @request.should_receive(:callback).and_yield({@identity => {"tags" => [@tag]}, @agent_href => {"tags" => [@tag]}}).once
+      @manager.query_tags_raw(@tag) { |r| @result = r }
+      @result.should == "raw response"
+    end
+
+    it "queries for agents having multiple tags always yields raw response" do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :tags => @tags}, {}).and_return(@request).once
+      @request.should_receive(:callback).and_yield({@agent_href => {"tags" => @tags}}).once
+      @manager.query_tags_raw(@tags) { |r| @result = r }
+      @result.should == "raw response"
+    end
+
+    it "queries for selected agents" do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :hrefs => @hrefs, :tags => @tags}, {}).and_return(@request).once
+      @request.should_receive(:callback).and_yield({@agent_href => {"tags" => @tags}}).once
+      @manager.query_tags_raw(@tags, @hrefs) { |r| @result = r }
+      @result.should == "raw response"
+    end
+
+    it "forwards timeout option" do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :tags => @tags}, {:timeout => 9}).and_return(@request).once
+      @request.should_receive(:callback).and_yield({@identity => {"tags" => [@tag]}}).once
+      @manager.query_tags_raw(@tags, nil, :timeout => 9) { |r| @result = r }
+      @result.should == "raw response"
+    end
+  end
+
+  context :add_tags do
+
+    before(:each) do
+      @request.should_receive(:raw_response).and_return("raw response").once
+      @agent.should_receive(:tags).and_return([]).once.by_default
+      @agent.should_receive(:tags=).once.by_default
+    end
+
+    it "adds individual tag to agent" do
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}).and_return(@request).once
+      @manager.add_tags(@tag).should be_true
+    end
+
+    it "adds multiple tags to agent" do
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => @tags}).and_return(@request).once
+      @manager.add_tags(@tags).should be_true
+    end
+
+    it "optionally yields raw response" do
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => @tags}).and_return(@request).once
+      @request.should_receive(:callback).and_yield("result").once
+      @manager.add_tags(@tags) { |r| @result = r }
+      @result.should == "raw response"
+    end
+
+    it "updates local tags" do
+      @agent.should_receive(:tags).and_return([@tag1]).once
+      @agent.should_receive(:tags=).should_receive([@tag]).once
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}).and_return(@request).once
+      @manager.add_tags(@tag).should be_true
+    end
+  end
+
+  context :remove_tags do
+
+    before(:each) do
+      @request.should_receive(:raw_response).and_return("raw response").once
+      @agent.should_receive(:tags).and_return([@tag]).once.by_default
+      @agent.should_receive(:tags=).once.by_default
+    end
+
+    it "removes individual tag to agent" do
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => [@tag]}).and_return(@request).once
+      @manager.remove_tags(@tag).should be_true
+    end
+
+    it "removes multiple tags to agent" do
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => @tags}).and_return(@request).once
+      @manager.remove_tags(@tags).should be_true
+    end
+
+    it "optionally yields raw response" do
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => @tags}).and_return(@request).once
+      @request.should_receive(:callback).and_yield("result").once
+      @manager.remove_tags(@tags) { |r| @result = r }
+      @result.should == "raw response"
+    end
+
+    it "updates local tags" do
+      @agent.should_receive(:tags).and_return([]).once
+      @agent.should_receive(:tags=).should_receive([@tag]).once
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => [@tag]}).and_return(@request).once
+      @manager.remove_tags(@tag).should be_true
+    end
+  end
+
+  context :do_update do
+
+    before(:each) do
+      @agent.should_receive(:tags).and_return([]).once.by_default
+    end
+
+    it "checks that agent has been set" do
+      @manager.agent = nil
+      @agent.should_receive(:tags).never
+      lambda { @manager.send(:do_update, [@tag], []) }.should \
+          raise_error(ArgumentError, "Must set agent= before using tag manager")
+    end
+
+    it "does not allow both add and removal of tags in same request" do
+      @agent.should_receive(:tags).never
+      lambda { @manager.send(:do_update, [@tag], [@tag1]) }.should \
+          raise_error(ArgumentError, "Cannot add and remove tags in same update")
+    end
+
+    it "adds tags for agent" do
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}).and_return(@request).once
+      @agent.should_receive(:tags=).never
+      @manager.send(:do_update, [@tag], []).should be_true
+    end
+
+    it "removes tags for agent" do
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => [@tag1]}).and_return(@request).once
+      @agent.should_receive(:tags=).never
+      @manager.send(:do_update, [], [@tag1]).should be_true
+    end
+
+    it "yields raw response if block given" do
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}).and_return(@request).once
+      @request.should_receive(:raw_response).and_return("raw response").once
+      @agent.should_receive(:tags=).once
+      @manager.send(:do_update, [@tag], []) { |r| @result = r }
+      @result.should == "raw response"
+    end
+
+    it "updates local tags if block given and successful" do
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}).and_return(@request).once
+      @request.should_receive(:raw_response).and_return("raw response").once
+      @agent.should_receive(:tags=).with([@tag]).once
+      @manager.send(:do_update, [@tag], []) { |r| @result = r }
+      @result.should == "raw response"
+    end
+
+    it "yields error result and does not update local tags" do
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}).and_return(@request).once
+      @request.should_receive(:raw_response).and_return("error").once
+      @request.should_receive(:errback).and_yield("error").once
+      @request.should_receive(:callback).once
+      @agent.should_receive(:tags=).never
+      @manager.send(:do_update, [@tag], []) { |r| @result = r }
+      @result.should == "error"
+    end
+  end
+
+  context :clear do
+
+    it "clears all agent tags" do
+      @request.should_receive(:raw_response).and_return("raw response").once
+      @agent.should_receive(:tags).and_return(@tags).twice
+      @agent.should_receive(:tags=).with([]).once
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => @tags}).and_return(@request).once
+      @manager.clear { |r| @result = r }
+      @result.should == "raw response"
+    end
+  end
+end

data/spec/clients/api_client_spec.rb

@@ -0,0 +1,423 @@
+# encoding: utf-8
+
+#--
+# Copyright (c) 2013 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'right_agent', 'clients', 'api_client'))
+
+describe RightScale::ApiClient do
+
+  include FlexMock::ArgumentTypes
+
+  before(:each) do
+    @log = flexmock(RightScale::Log)
+    @log.should_receive(:error).by_default.and_return { |m| raise RightScale::Log.format(*m) }
+    @log.should_receive(:warning).by_default.and_return { |m| raise RightScale::Log.format(*m) }
+    @timer = flexmock("timer", :cancel => true, :interval= => 0).by_default
+    flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).and_yield.by_default
+    @account_id = 123
+    @agent_id = "rs-instance-1-1"
+    @agent_href = "/api/clouds/1/instances/1"
+    @agent_href2 = "/api/clouds/2/instances/2"
+    @links = {"links" => [{"rel" => "self", "href" => @agent_href}]}
+    @http_client = flexmock("http client", :get => @links, :check_health => true).by_default
+    flexmock(RightScale::BalancedHttpClient).should_receive(:new).and_return(@http_client).by_default
+    @url = "http://test.com"
+    @auth_header = {"Authorization" => "Bearer <session>"}
+    @auth_client = AuthClientMock.new(@url, @auth_header, :authorized, @account_id, @agent_id)
+    @options = {}
+    @client = RightScale::ApiClient.new(@auth_client, @options)
+    @version = RightScale::AgentConfig.protocol_version
+    @payload = {:agent_identity => @agent_id}
+    @target = nil
+    @token = "random token"
+  end
+
+  context :initialize do
+    it "initializes options" do
+      @options = {
+        :open_timeout => 1,
+        :request_timeout => 2,
+        :listen_timeout => 3,
+        :retry_timeout => 4,
+        :retry_intervals => [1, 2, 3],
+        :reconnect_interval => 5 }
+      @client = RightScale::ApiClient.new(@auth_client, @options)
+      options = @client.instance_variable_get(:@options)
+      options[:server_name] = "RightApi"
+      options[:api_version] = "1.5"
+      options[:open_timeout] = 1
+      options[:request_timeout] = 2
+      options[:retry_timeout] = 3
+      options[:retry_intervals] = [1, 2, 3]
+      options[:reconnect_interval] = 4
+    end
+  end
+
+  context :push do
+    it "makes mapped request" do
+      flexmock(@client).should_receive(:make_request).with(:post, "/audit_entries/111/append", {:detail => "details"},
+          "update_entry", @token, Hash).and_return(nil).once
+      @client.push("/auditor/update_entry", @payload.merge(:audit_id => 111, :detail => "details"), @target, @token).should be_nil
+    end
+
+    it "does not require token" do
+      flexmock(@client).should_receive(:make_request).with(:post, "/audit_entries/111/append", {:detail => "details"},
+          "update_entry", nil, Hash).and_return(nil).once
+      @client.push("/auditor/update_entry", @payload.merge(:audit_id => 111, :detail => "details"), @target).should be_nil
+    end
+  end
+
+  context :request do
+    it "makes mapped request" do
+      flexmock(@client).should_receive(:make_request).with(:post, "/right_net/booter/declare", {:r_s_version => @version},
+          "declare", @token, Hash).and_return(nil).once
+      @client.push("/booter/declare", @payload.merge(:r_s_version => @version), @target, @token).should be_nil
+    end
+
+    it "maps query_tags request" do
+      flexmock(@client).should_receive(:map_query_tags).with(:post, {:tags => ["a:b=c"]}, "query_tags", @token, Hash).
+          and_return({}).once
+      @client.request("/router/query_tags", @payload.merge(:tags => ["a:b=c"]), @target, @token).should == {}
+    end
+
+    it "does not require token" do
+      flexmock(@client).should_receive(:make_request).with(:post, "/right_net/booter/declare", {:r_s_version => @version},
+          "declare", nil, Hash).and_return(nil).once
+      @client.push("/booter/declare", @payload.merge(:r_s_version => @version), @target).should be_nil
+    end
+  end
+
+  context :support? do
+    it "returns true if request type is supported" do
+      @client.support?("/booter/declare").should be_true
+    end
+
+    it "returns false if request type is not supported" do
+      @client.support?("/instance_scheduler/execute").should be_false
+    end
+  end
+
+  context :map_request do
+    it "raises if request type not supported" do
+      lambda { @client.send(:map_request, "/instance_scheduler/execute", @payload, @token) }.should \
+          raise_error(ArgumentError, "Unsupported request type: /instance_scheduler/execute")
+    end
+
+    it "makes request" do
+      flexmock(@client).should_receive(:make_request).with(:post, "/right_net/booter/declare", {:r_s_version => @version},
+          "declare", @token, Hash).and_return(nil).once
+      @client.send(:map_request, "/booter/declare", @payload.merge(:r_s_version => @version), @token).should be_nil
+    end
+
+    it "returns mapped response" do
+      flexmock(@client).should_receive(:make_request).with(:post, "/audit_entries",
+          {:audit_entry => {:auditee_href => @agent_href, :summary => "summary"}}, "create_entry", @token, Hash).
+          and_return("/api/audit_entries/111").once
+      @client.send(:map_request, "/auditor/create_entry", @payload.merge(:summary => "summary"), @token).should == "111"
+    end
+  end
+
+  context :map_response do
+    it "converts audit entry href in result to an audit ID" do
+      response = "/api/audit_entries/111"
+      @client.send(:map_response, response, "/audit_entries").should == "111"
+    end
+
+    it "converts tag query result to list of tags for resource" do
+      response = [
+        { "actions" => [],
+          "links" =>   [{"rel" => "resource", "href" => "/api/clouds/6/instances/CUPVAL7KUP7TF"}],
+          "tags" =>    [{"name" => "rs_agent_dev:log_level=debug"},
+                        {"name" => "rs_login:state=restricted"},
+                        {"name" => "rs_monitoring:state=active"}] },
+        { "actions" => [],
+          "links" =>   [{"rel" => "resource", "href" => "/api/servers/20"}],
+          "tags" =>    [{"name" => "server:ready=now"},
+                        {"name" => "rs_agent_dev:log_level=debug"}] } ]
+      @client.send(:map_response, response, "/tags/by_resource").should ==
+          { "/api/clouds/6/instances/CUPVAL7KUP7TF" => { "tags" => ["rs_agent_dev:log_level=debug",
+                                                                    "rs_login:state=restricted",
+                                                                    "rs_monitoring:state=active"] } }
+    end
+  end
+
+  context "query tags" do
+    before(:each) do
+      @action = "query_tags"
+      @options = {}
+      @tags = ["a:b=c"]
+      @hrefs = [@agent_href2]
+      @response = [
+        { "actions" => [],
+          "links" =>   [{"rel" => "resource", "href" => @agent_href}],
+          "tags" =>    [{"name" => "a:b=c"}, {"name" => "x:y=z"}] } ]
+    end
+
+    context :map_query_tags do
+      it "retrieves resource hrefs for specified tags" do
+        params = {:tags => @tags}
+        params2 = params.merge(:match_all => false, :resource_type => "instances")
+        flexmock(@client).should_receive(:query_by_resource).never
+        flexmock(@client).should_receive(:make_request).with(:post, "/tags/by_tag", params2, @action, @token, @options).and_return({}).once
+        @client.send(:map_query_tags, :post, params, @action, @token, @options).should == {}
+      end
+
+      it "appends retrieved hrefs to any specified resource hrefs" do
+        params = {:tags => @tags, :resource_hrefs => @hrefs}
+        params2 = {:resource_hrefs => [@agent_href2, @agent_href]}
+        flexmock(@client).should_receive(:query_by_tag).with(:post, @tags, @action, @token, @options).and_return([@agent_href]).once
+        flexmock(@client).should_receive(:make_request).with(:post, "/tags/by_resource", params2, @action, @token, @options).and_return({}).once
+        @client.send(:map_query_tags, :post, params, @action, @token, @options).should == {}
+      end
+
+      it "queries for tags for each resource href" do
+        params = {:resource_hrefs => @hrefs}
+        flexmock(@client).should_receive(:query_by_tag).never
+        flexmock(@client).should_receive(:make_request).with(:post, "/tags/by_resource", params, @action, @token, @options).and_return(@response).once
+        @client.send(:map_query_tags, :post, params, @action, @token, @options).should == {@agent_href => {"tags" => ["a:b=c", "x:y=z"]}}
+      end
+    end
+
+    context :query_by_tag do
+      before(:each) do
+        @params = {:tags => @tags}
+        @params2 = @params.merge(:match_all => false, :resource_type => "instances")
+      end
+
+      it "queries for tags using specified tags" do
+        flexmock(@client).should_receive(:make_request).with(:post, "/tags/by_tag", @params2, @action, @token, @options).and_return({}).once
+        @client.send(:query_by_tag, :post, @tags, @action, @token, @options).should == []
+      end
+
+      it "maps response" do
+        flexmock(@client).should_receive(:make_request).with(:post, "/tags/by_tag", @params2, @action, @token, @options).and_return(@response).once
+        @client.send(:query_by_tag, :post, @tags, @action, @token, @options).should == [@agent_href]
+      end
+    end
+
+    context :query_by_resource do
+      before(:each) do
+        @params = {:resource_hrefs => @hrefs}
+      end
+
+      it "queries for tags using specified hrefs" do
+        flexmock(@client).should_receive(:make_request).with(:post, "/tags/by_resource", @params, @action, @token, @options).and_return({}).once
+        @client.send(:query_by_resource, :post, @hrefs, @action, @token, @options).should == {}
+      end
+
+      it "maps response" do
+        flexmock(@client).should_receive(:make_request).with(:post, "/tags/by_resource", @params, @action, @token, @options).and_return(@response).once
+        @client.send(:query_by_resource, :post, @hrefs, @action, @token, @options).should == {@agent_href => {"tags" => ["a:b=c", "x:y=z"]}}
+      end
+    end
+  end
+
+  context :parameterize do
+
+    context "for audits" do
+      before(:each) do
+        @path, @params, @options = @client.send(:parameterize, "auditor", "update_entry", @payload.merge(:audit_id => 111,
+                                                :detail => "details"), "/audit_entries/:id/append")
+      end
+
+      it "converts audit parameters" do
+        @params.should == {:detail => "details"}
+      end
+
+      it "substitutes audit ID into path" do
+        @path.should == "/audit_entries/111/append"
+      end
+
+      it "adds parameter filter to options" do
+        @options.should == {:filter_params => ["detail", "text"]}
+      end
+    end
+
+    context "for tags" do
+      before(:each) do
+        tags = ["a:b=c", nil, [nil, "x:y=z"]]
+        @path, @params, @options = @client.send(:parameterize, "router", "add_tags", @payload.merge(:tags => tags),
+                                                "/tags/multi_add")
+      end
+
+      it "adds default resource href to parameters" do
+        @params[:resource_hrefs].should == [@agent_href]
+      end
+
+      it "adds specified resource hrefs to parameters" do
+        hrefs = [@agent_href, @agent_href2]
+        _, @params, _ = @client.send(:parameterize, "router", "query_tags", @payload.merge(:hrefs => hrefs),
+                                     "/tags/by_resource")
+        @params[:resource_hrefs].should == hrefs
+      end
+
+      it "ensures that tags parameter is properly formed" do
+        @params[:tags].should == ["a:b=c", "x:y=z"]
+      end
+
+      it "does not add tags if not present" do
+        _, @params, _ = @client.send(:parameterize, "router", "query_tags", @payload, "/tags/multi_add")
+        @params.should_not have_key(:tags)
+      end
+    end
+
+    context "otherwise" do
+      before(:each) do
+        @path, @params, @options = @client.send(:parameterize, "booter", "declare", @payload.merge(:r_s_version => @version),
+                                                "/right_net/booter/declare")
+      end
+
+      it "removes :agent_identity parameter" do
+        @params[:agent_identity].should be_nil
+      end
+    end
+  end
+
+  context :parameterize_audit do
+
+    context "create_entry" do
+      it "stores instance href" do
+        @client.send(:parameterize_audit, "create_entry", @payload)[:audit_entry][:auditee_href].should == @agent_href
+      end
+
+      context "summary" do
+        it "stores summary if non-blank" do
+          @client.send(:parameterize_audit, "create_entry", :summary => "hello")[:audit_entry][:summary].should == "hello"
+          @client.send(:parameterize_audit, "create_entry", :summary => "")[:audit_entry].should_not have_key(:summary)
+          @client.send(:parameterize_audit, "create_entry", {})[:audit_entry].should_not have_key(:summary)
+        end
+
+        it "truncates summary if too long" do
+          @client.send(:parameterize_audit, "create_entry", :summary => "hello " * 50)[:audit_entry][:summary].size.should == 255
+        end
+      end
+
+      it "stores detail if non-blank" do
+        @client.send(:parameterize_audit, "create_entry", :detail => "details")[:audit_entry][:detail].should == "details"
+        @client.send(:parameterize_audit, "create_entry", :detail => "")[:audit_entry].should_not have_key(:detail)
+        @client.send(:parameterize_audit, "create_entry", {})[:audit_entry].should_not have_key(:detail)
+      end
+
+      it "stores user email if non-blank" do
+        @client.send(:parameterize_audit, "create_entry", :user_email => "email")[:user_email].should == "email"
+        @client.send(:parameterize_audit, "create_entry", :user_email => "").should_not have_key(:user_email)
+        @client.send(:parameterize_audit, "create_entry", {}).should_not have_key(:user_email)
+      end
+
+      it "stores notify category if present" do
+        @client.send(:parameterize_audit, "create_entry", :category => "Notification")[:notify].should == "Notification"
+        @client.send(:parameterize_audit, "create_entry", {}).should_not have_key(:notify)
+      end
+    end
+
+    context "update_entry" do
+      it "stores offset if present" do
+        @client.send(:parameterize_audit, "update_entry", :offset => 100)[:offset].should == 100
+        @client.send(:parameterize_audit, "update_entry", {}).should_not have_key(:offset)
+      end
+
+      context "summary" do
+        it "stores summary if non-blank" do
+          @client.send(:parameterize_audit, "update_entry", :summary => "hello")[:summary].should == "hello"
+          @client.send(:parameterize_audit, "update_entry", :summary => "").should_not have_key(:summary)
+          @client.send(:parameterize_audit, "update_entry", {}).should_not have_key(:summary)
+        end
+
+        it "truncates summary if too long" do
+          @client.send(:parameterize_audit, "update_entry", :summary => "hello " * 50)[:summary].size.should == 255
+        end
+
+        it "stores notify category if present and summary is non-blank" do
+          @client.send(:parameterize_audit, "update_entry", :summary => "hello", :category => "Notification")[:notify].should == "Notification"
+          @client.send(:parameterize_audit, "update_entry", :category => "Notification").should_not have_key(:notify)
+        end
+      end
+
+      it "stores detail if non-blank" do
+        @client.send(:parameterize_audit, "update_entry", :detail => "details")[:detail].should == "details"
+        @client.send(:parameterize_audit, "update_entry", :detail => "").should_not have_key(:detail)
+        @client.send(:parameterize_audit, "update_entry", {}).should_not have_key(:detail)
+      end
+    end
+
+    context "otherwise" do
+      it "raises unknown audit" do
+        lambda { @client.send(:parameterize_audit, "bogus", {}) }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context :truncate do
+    it "returns non-string as is" do
+      @client.send(:truncate, nil, 5).should == nil
+    end
+
+    it "returns strings shorter than limit as is" do
+      @client.send(:truncate, "hello", 5).should == "hello"
+    end
+
+    it "requires max length to be greater than 3" do
+      @client.send(:truncate, "hello", 4).should == "h..."
+      lambda { @client.send(:truncate, "hello", 3) }.should raise_error(ArgumentError)
+    end
+
+    it "truncates strings that are too long" do
+      @client.send(:truncate, "how you doing", 10).bytesize.should == 10
+    end
+
+    it "ends truncated string with an ellipsis" do
+      @client.send(:truncate, "how you doing", 10).should == "how you..."
+    end
+
+    it "accounts for multi-byte characters" do
+      @client.send(:truncate, "Schös Tägli wünschi", 20).should == "Schös Tägli wü..."
+      @client.send(:truncate, "Schös Tägli wünschi", 19).should == "Schös Tägli w..."
+      @client.send(:truncate, "Schös Tägli wünschi", 18).should == "Schös Tägli w..."
+      @client.send(:truncate, "Schös Tägli wünschi", 17).should == "Schös Tägli ..."
+    end
+  end
+
+  context :non_blank do
+    it "returns nil if value nil" do
+      @client.send(:non_blank, nil).should be_nil
+    end
+
+    it "returns nil if value is empty" do
+      @client.send(:non_blank, "").should be_nil
+    end
+
+    it "returns nil if value nil" do
+      @client.send(:non_blank, "hello").should == "hello"
+    end
+  end
+
+  context :enable_use do
+    it "makes API request to get links for setting instance href" do
+      flexmock(@client).should_receive(:make_request).with(:get, "/sessions/instance", {}, "instance").and_return(@links).once
+      @client.instance_variable_get(:@self_href).should == @agent_href
+      @client.send(:enable_use).should be_true
+    end
+  end
+end