vcloud-core 0.0.9 → 0.0.10

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.0.10 (2014-03-17)
+
+Features:
+
+  - separates out the query runner tool that interfaces with fog from the CLI tool
+
+Deprecated:
+
+  - Vcloud::Query.get_all_results should no longer be used - use Vcloud::QueryRunner.run instead
+
 ## 0.0.9 (2014-03-10)
 
 Features:

data/bin/vcloud-query

@@ -41,10 +41,6 @@ class App
     options[:output_format] = v.downcase
   end
 
-  on("--mock",    "Fog Mock mode")
-  on("--verbose", "Verbose output")
-  on("--debug",   "Debugging output")
-
   arg :type, :optional
 
   description '

data/lib/vcloud/core.rb

@@ -16,6 +16,7 @@ require 'vcloud/core/vapp'
 require 'vcloud/core/vapp_template'
 require 'vcloud/core/org_vdc_network'
 require 'vcloud/core/query'
+require 'vcloud/core/query_runner'
 
 module Vcloud
   module Core

data/lib/vcloud/core/edge_gateway.rb

@@ -12,8 +12,8 @@ module Vcloud
       end
 
       def self.get_ids_by_name(name)
-        q = Query.new('edgeGateway', :filter => "name==#{name}")
-        unless res = q.get_all_results
+        q = QueryRunner.new
+        unless res = q.run('edgeGateway', :filter => "name==#{name}")
           raise "Error finding edgeGateway by name #{name}"
         end
         res.collect do |record| 

data/lib/vcloud/core/query.rb

@@ -3,101 +3,59 @@ require 'csv'
 module Vcloud
   class Query
 
-    attr_reader :type
-    attr_reader :options
-
-    def initialize(type=nil, options={})
+    def initialize(type=nil, options={}, query_runner = Vcloud::QueryRunner.new)
       @type = type
       @options = options
       @options[:output_format] ||= 'tsv'
-      Fog.mock! if ENV['FOG_MOCK'] || options[:mock]
-      @fsi = Vcloud::Fog::ServiceInterface.new
-    end
-
-    def filter
-      options[:filter]
-    end
-
-    def output_format
-      options[:output_format]
-    end
-
-    def fields
-      options[:fields]
+      @query_runner = query_runner
     end
 
     def run()
-
-      puts "options:" if @options[:debug]
-      pp @options if @options[:debug]
-
       if @type.nil?
-        output_potential_query_types
+        output_available_query_types
       else
         output_query_results
       end
     end
 
+    # <b>DEPRECATED:</b> Please use <tt>Vcloud::QueryRunner.run</tt> instead.
     def get_all_results
-      results = []
-      (1..get_num_pages).each do |page|
-        results += get_results_page(page) || []
-      end
-      results
-    end
-
-    private
-
-    def get_num_pages
-      body = @fsi.get_execute_query(type=@type, @options)
-      last_page = body[:lastPage] || 1
-      raise "Invalid lastPage (#{last_page}) in query results" unless last_page.is_a? Integer
-      return last_page.to_i
-    end
-
-    def get_results_page(page)
-      raise "Must supply a page number" if page.nil?
-
-      begin
-        body = @fsi.get_execute_query(type=@type, @options.merge({:page=>page}))
-        pp body if @options[:debug]
-      rescue ::Fog::Compute::VcloudDirector::BadRequest, ::Fog::Compute::VcloudDirector::Forbidden => e
-        raise "Access denied: #{e.message}"
-      end
-
-      records = body.keys.detect {|key| key.to_s =~ /Record|Reference$/}
-      body[records] = [body[records]] if body[records].is_a?(Hash)
-      return nil if body[records].nil? || body[records].empty?
-      body[records]
-
+      warn "[DEPRECATION] `Vcloud::Query::get_all_results` is deprecated.  Please use `Vcloud::QueryRunner.run` instead."
+      @query_runner.run(@type, @options)
     end
 
+  private
     def output_query_results
-      results = get_all_results
+      results = @query_runner.run(@type, @options)
       output_header(results)
       output_results(results)
     end
 
-    def output_potential_query_types
+    def output_available_query_types
+      available_query_types = @query_runner.available_query_types
+      available_queries = collate_formats_for_types(available_query_types)
+      print_query_types(available_queries)
+    end
 
-      query_list = @fsi.get_execute_query
-      queries = {}
-      type_width = 0
-      query_list[:Link].select do |link|
-        link[:rel] == 'down'
-      end.map do |link|
-        href = Nokogiri::XML.fragment(link[:href])
-        query = CGI.parse(URI.parse(href.text).query)
-        [query['type'].first, query['format'].first]
-      end.each do |type, format|
-        queries[type] ||= []
+    def collate_formats_for_types(available_queries)
+      queries = Hash.new { |h, k| h[k]=[] }
+      available_queries.each do |type, format|
         queries[type] << format
-        type_width = [type_width, type.size].max
       end
+      queries
+    end
+
+    def print_query_types(queries)
+      type_width = longest_query_type(queries)
+
       queries.keys.sort.each do |type|
         puts "%-#{type_width}s %s" % [type, queries[type].sort.join(',')]
       end
+    end
 
+    def longest_query_type(queries)
+      return 0 if queries.keys.empty?
+      queries.keys.max_by{|key| key.length}.length
     end
 
     def output_header(results)
@@ -134,9 +92,7 @@ module Vcloud
       else
         raise "Unsupported output format #{@options[:output_format]}"
       end
-
     end
 
   end
 end
-

data/lib/vcloud/core/query_runner.rb

@@ -0,0 +1,52 @@
+module Vcloud
+
+  class QueryRunner
+    def initialize
+      @fsi = Vcloud::Fog::ServiceInterface.new
+    end
+
+    def run(type=nil, options={})
+      get_all_results(type, options)
+    end
+
+    def available_query_types
+      query_list = @fsi.get_execute_query()
+      query_list[:Link].select do |link|
+        link[:rel] == 'down'
+      end.map do |link|
+        href  = Nokogiri::XML.fragment(link[:href])
+        query = CGI.parse(URI.parse(href.text).query)
+        [query['type'].first, query['format'].first]
+      end
+    end
+
+  private
+
+    def get_all_results(type, options)
+      results = []
+      (1..get_num_pages(type, options)).each do |page|
+        results += get_results_page(page, type, options) || []
+      end
+      results
+    end
+
+    def get_num_pages(type, options)
+      body = @fsi.get_execute_query(type, options)
+      last_page = body[:lastPage] || 1
+      raise "Invalid lastPage (#{last_page}) in query results" unless last_page.is_a? Integer
+      last_page.to_i
+    end
+
+    def get_results_page(page, type, options)
+      body = @fsi.get_execute_query(type, options.merge({:page=>page}))
+
+      record_key = key_of_first_record_or_reference(body)
+      body[record_key] = [body[record_key]] if body[record_key].is_a?(Hash)
+      body[record_key]
+    end
+
+    def key_of_first_record_or_reference(body)
+      body.keys.detect { |key| key.to_s =~ /Record|Reference$/ }
+    end
+  end
+end

data/lib/vcloud/core/vapp.rb

@@ -13,8 +13,8 @@ module Vcloud
       end
 
       def self.get_by_name(name)
-        q = Query.new('vApp', :filter => "name==#{name}")
-        unless res = q.get_all_results
+        q = QueryRunner.new
+        unless res = q.run('vApp', :filter => "name==#{name}")
           raise "Error finding vApp by name #{name}"
         end
         case res.size

data/lib/vcloud/core/vapp_template.rb

@@ -25,11 +25,8 @@ module Vcloud
 
       def self.get_ids_by_name_and_catalog name, catalog_name
         raise "provide Catalog and vAppTemplate name" unless name && catalog_name
-        q = Query.new(
-          'vAppTemplate',
-          :filter => "name==#{name};catalogName==#{catalog_name}"
-        )
-        unless query_results = q.get_all_results
+        q = QueryRunner.new
+        unless query_results = q.run('vAppTemplate', :filter => "name==#{name};catalogName==#{catalog_name}")
           raise "Error retreiving #{q.type} query '#{q.filter}'"
         end
         query_results.collect do |record|

data/lib/vcloud/core/vdc.rb

@@ -12,8 +12,8 @@ module Vcloud
       end
 
       def self.get_by_name(name)
-        q = Query.new('orgVdc', :filter => "name==#{name}")
-        unless res = q.get_all_results
+        q = QueryRunner.new
+        unless res = q.run('orgVdc', :filter => "name==#{name}")
           raise "Error finding vDC by name #{name}"
         end
         raise "vDc #{name} not found" unless res.size == 1

data/lib/vcloud/core/version.rb

@@ -1,5 +1,5 @@
 module Vcloud
   module Core
-    VERSION = '0.0.9'
+    VERSION = '0.0.10'
   end
 end

data/lib/vcloud/core/vm.rb

@@ -139,12 +139,12 @@ module Vcloud
       end
 
       def get_storage_profile_href_by_name(storage_profile_name, vapp_name)
-        q = Query.new('vApp', :filter => "name==#{vapp_name}")
-        vdc_results = q.get_all_results
+        q = QueryRunner.new
+        vdc_results = q.run('vApp', :filter => "name==#{vapp_name}")
         vdc_name = vdc_results.first[:vdcName]
 
-        q = Query.new('orgVdcStorageProfile', :filter => "name==#{storage_profile_name};vdcName==#{vdc_name}")
-        sp_results = q.get_all_results
+        q = QueryRunner.new
+        sp_results = q.run('orgVdcStorageProfile', :filter => "name==#{storage_profile_name};vdcName==#{vdc_name}")
 
         if sp_results.empty? or !sp_results.first.has_key?(:href)
           raise "storage profile not found"

data/spec/vcloud/core/edge_gateway_spec.rb

@@ -48,8 +48,9 @@ module Vcloud
           q_results = [
             { :name => 'edgegw-test-1', :href => "/#{@edgegw_id}" }
           ]
-          mock_query = double(:query, :get_all_results => q_results)
-          Vcloud::Query.should_receive(:new).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(mock_query)
+          mock_query = double(:query_runner)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_query)
+          mock_query.should_receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
           @obj = EdgeGateway.get_by_name('edgegw-test-1')
           expect(@obj.class).to be(Vcloud::Core::EdgeGateway)
         end
@@ -58,16 +59,18 @@ module Vcloud
           q_results = [
             { :name => 'edgegw-test-1', :href => "/#{@edgegw_id}" }
           ]
-          mock_query = double(:query, :get_all_results => q_results)
-          Vcloud::Query.should_receive(:new).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(mock_query)
+          mock_query = double(:query_runner)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_query)
+          mock_query.should_receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
           @obj = EdgeGateway.get_by_name('edgegw-test-1')
           expect(@obj.id) == @edgegw_id
         end
 
         it "should raise an error if no edgegw with that name exists" do
           q_results = [ ]
-          mock_query = double(:query, :get_all_results => q_results)
-          Vcloud::Query.should_receive(:new).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(mock_query)
+          mock_query = double(:query_runner)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_query)
+          mock_query.should_receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
           expect{ EdgeGateway.get_by_name('edgegw-test-1') }.to raise_exception(RuntimeError, "edgeGateway edgegw-test-1 not found")
         end
 

data/spec/vcloud/core/org_vdc_network_spec.rb

@@ -110,7 +110,7 @@ module Vcloud
             q_results = [
               { :name => @net_name, :href => "/#{@net_id}" }
             ]
-            @mock_net_query = double(:query, :get_all_results => q_results)
+            @mock_net_query = double(:query_runner, :run => q_results)
             @config = {
               :name => @net_name,
               :vdc_name => @vdc_name,

data/spec/vcloud/core/query_runner_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe Vcloud::QueryRunner do
+  before(:each) do
+    @mock_fog_interface = StubFogInterface.new
+    Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+    @query_runner = Vcloud::QueryRunner.new()
+  end
+
+  context '#available_query_types' do
+    it 'should return empty array if no data' do
+      @mock_fog_interface.stub(:get_execute_query).and_return({:Link => {}})
+
+      result = @query_runner.available_query_types
+
+      result.size.should == 0
+    end
+
+    it 'should parse the query types returned' do
+      @mock_fog_interface.stub(:get_execute_query).and_return(
+        {:Link => [
+          {:rel  => 'down',
+           :href => 'query?type=alice&format=references'},
+        ]})
+
+      result = @query_runner.available_query_types
+
+      result.size.should == 1
+      result[0][0].should == 'alice'
+      result[0][1].should == 'references'
+    end
+
+    it 'should return the set of data' do
+      @mock_fog_interface.stub(:get_execute_query).and_return(
+        {:Link => [
+          {:rel  => 'down',
+           :href => 'query?type=alice&format=references'},
+          {:rel  => 'down',
+           :href => 'query?type=bob&format=references'},
+        ]})
+
+      result = @query_runner.available_query_types
+
+      result.size.should == 2
+    end
+  end
+
+  context '#run' do
+    it 'should return no results when fog returns no results' do
+      @mock_fog_interface.stub(:get_execute_query).and_return({})
+
+      result = @query_runner.run()
+
+      result.should == []
+    end
+
+    it 'return no results when fog results do not include a "Record" or a "Reference"' do
+      @mock_fog_interface.stub(:get_execute_query).and_return(
+        {
+          :WibbleBlob => {:field1 => 'Stuff 1'}
+        }
+      )
+
+      result = @query_runner.run()
+
+      result.size.should == 0
+    end
+
+    it 'should return a single result when fog returns a single record' do
+      fields = {:field1 => 'Stuff 1'}
+      @mock_fog_interface.stub(:get_execute_query).and_return(
+        {
+          :WibbleRecord => [fields]
+        }
+      )
+
+      result = @query_runner.run()
+
+      result.size.should == 1
+      result[0].should == fields
+    end
+
+    it 'should return a single result when fog returns a single reference' do
+      fields = {:field1 => 'Stuff 1'}
+      @mock_fog_interface.stub(:get_execute_query).and_return(
+        {
+          :WibbleReference => [fields]
+        }
+      )
+
+      result = @query_runner.run()
+
+      result.size.should == 1
+      result[0].should == fields
+    end
+
+    it 'should wrap single result from fog in list' do
+      fields = {:field1 => 'Stuff 1'}
+      @mock_fog_interface.stub(:get_execute_query).and_return(
+        {
+          :WibbleRecord => fields
+        }
+      )
+
+      result = @query_runner.run()
+
+      result.size.should == 1
+      result[0].should == fields
+    end
+
+    it 'should return all results in a record returned by fog' do
+      fields      = {:field1 => 'Stuff 1'}
+      more_fields = {:field1 => 'More Stuff 1'}
+      @mock_fog_interface.stub(:get_execute_query).and_return(
+        {
+          :WibbleRecord => [fields, more_fields]
+        }
+      )
+
+      result = @query_runner.run()
+
+      result.size.should == 2
+      result[0].should == fields
+      result[1].should == more_fields
+    end
+
+    it 'should return the first item if more than one records provided' do
+      fields1 = {:field1 => 'Stuff 1'}
+      fields2 = {:field1 => 'Stuff 2'}
+      @mock_fog_interface.stub(:get_execute_query).and_return(
+        {
+          :WibbleRecord => [fields1],
+          :WobbleRecord => [fields2]
+        }
+      )
+
+      result = @query_runner.run()
+
+      result.size.should == 1
+      result[0].should == fields1
+    end
+
+    it 'should raise error if lastPage is not an integer' do
+      @mock_fog_interface.stub(:get_execute_query).and_return(
+        {
+          :lastPage     => :qwerty,
+          :WibbleRecord => []
+        }
+      )
+
+      expect { @query_runner.run() }.to raise_error('Invalid lastPage (qwerty) in query results')
+    end
+
+    it 'should get each page and collect the results' do
+      fields = {:field1 => 'Stuff 1'}
+      @mock_fog_interface.stub(:get_execute_query).and_return(
+        {
+          :lastPage     => 2,
+          :WibbleRecord => [fields]
+        }
+
+      )
+      result = @query_runner.run()
+
+      result.size.should == 2
+      result[0].should == fields
+      result[1].should == fields
+    end
+  end
+end

data/spec/vcloud/core/query_spec.rb

@@ -3,38 +3,19 @@ require 'spec_helper'
 describe Vcloud::Query do
   context "attributes" do
 
-    context "our object should have methods" do
-      before(:each) do
-        @mock_fog_interface = StubFogInterface.new
-        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
-        @query = Vcloud::Query.new()
-      end
-      it { @query.should respond_to(:run) }
-    end
+    context "#run called with no type set on construction" do
 
-    context "#run with no type set" do
-      
-      before(:each) do
-        @mock_fog_interface = StubFogInterface.new
-        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
-        @query = @query = Vcloud::Query.new()
-      end
+      it "should get and reformat query types" do
+        query_runner = double(Vcloud::QueryRunner)
+        allow(query_runner).to receive(:available_query_types) {
+          [
+            ['alice', 'references'],
+            ['alice', 'records'],
+            ['bob', 'records']
+          ]
+        }
 
-      it "should call output_potential_query_types when run not provided with a type" do
-        @query.should_receive(:output_potential_query_types)
-        @query.run()
-      end
-
-      it "should output viable types when run not provided with a type" do
-        @mock_fog_interface.stub(:get_execute_query).and_return( 
-          { :Link => [
-            {:rel=>"down",
-             :href=>"query?type=alice&format=references"},
-            {:rel=>"down",
-             :href=>"query?type=alice&format=records"},
-            {:rel=>"down",
-             :href=>"query?type=bob&format=records"},
-        ]})
+        @query = Vcloud::Query.new(nil, {}, query_runner)
 
         @query.should_receive(:puts).with("alice records,references")
         @query.should_receive(:puts).with("bob   records")
@@ -45,23 +26,26 @@ describe Vcloud::Query do
     end
 
     context "gracefully handle zero results" do
+
       before(:each) do
-        @mock_fog_interface = StubFogInterface.new
-        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
-        @query = Vcloud::Query.new('bob')
-        @mock_fog_interface.stub(:get_execute_query).and_return({})
+        @query_runner = double(Vcloud::QueryRunner)
+        allow(@query_runner).to receive(:run) { {} }
       end
 
       it "should not output when given tsv output_format" do
-        @query = Vcloud::Query.new('bob', :output_format => 'tsv')
-        @query.should_not_receive(:puts)
-        @query.run()
+        query = Vcloud::Query.new('bob', {:output_format => 'tsv'}, @query_runner)
+
+        query.should_not_receive(:puts)
+
+        query.run()
       end
 
       it "should not output when given csv output_format" do
-        @query = Vcloud::Query.new('bob', :output_format => 'csv')
-        @query.should_not_receive(:puts)
-        @query.run()
+        query = Vcloud::Query.new('bob', {:output_format => 'csv'}, @query_runner)
+
+        query.should_not_receive(:puts)
+
+        query.run()
       end
 
     end
@@ -69,43 +53,36 @@ describe Vcloud::Query do
     context "get results with a single response page" do
 
       before(:each) do
-        @mock_fog_interface = StubFogInterface.new
-        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
-        @query = Vcloud::Query.new('bob')
-        @mock_fog_interface.stub(:get_execute_query).and_return( { 
-          :WibbleRecord=>
-            [{:field1=>"Stuff 1",
-              :field2=>"Stuff 2",
-              :field3=>"Stuff 3",
-            },
-             {:field1=>"More Stuff 1",
-              :field2=>"More Stuff 2",
-              :field3=>"More Stuff 3",
-            },
-            ]
-        } )
+        @query_runner = double(Vcloud::QueryRunner)
+        allow(@query_runner).to receive(:run) {
+          [
+            {:field1 => "Stuff 1", :field2 => "Stuff 2"},
+            {:field1 => "More Stuff 1", :field2 => "More Stuff 2"}
+          ]
+        }
       end
 
       it "should output a query in tsv when run with a type" do
-        @query = Vcloud::Query.new('bob', :output_format => 'tsv')
-        @query.should_receive(:puts).with("field1\tfield2\tfield3")
-        @query.should_receive(:puts).with("Stuff 1\tStuff 2\tStuff 3")
-        @query.should_receive(:puts).with("More Stuff 1\tMore Stuff 2\tMore Stuff 3")
+        @query = Vcloud::Query.new('bob', {:output_format => 'tsv'}, @query_runner)
+
+        @query.should_receive(:puts).with("field1\tfield2")
+        @query.should_receive(:puts).with("Stuff 1\tStuff 2")
+        @query.should_receive(:puts).with("More Stuff 1\tMore Stuff 2")
+
         @query.run()
       end
 
       it "should output a query in csv when run with a type" do
-        @query = Vcloud::Query.new('bob', :output_format => 'csv')
-        @query.should_receive(:puts).with("field1,field2,field3\n")
-        @query.should_receive(:puts).with("Stuff 1,Stuff 2,Stuff 3\nMore Stuff 1,More Stuff 2,More Stuff 3\n")
+        @query = Vcloud::Query.new('bob', {:output_format => 'csv'}, @query_runner)
+
+        @query.should_receive(:puts).with("field1,field2\n")
+        @query.should_receive(:puts).with("Stuff 1,Stuff 2\nMore Stuff 1,More Stuff 2\n")
+
         @query.run()
       end
 
-#      it "should output a query in yaml when run with a type"
-
     end
 
   end
 
 end
-

data/spec/vcloud/core/vapp_spec.rb

@@ -52,16 +52,18 @@ module Vcloud
           q_results = [
             { :name => 'vapp-test-1', :href => @vapp_id }
           ]
-          mock_query = double(:query, :get_all_results => q_results)
-          Vcloud::Query.should_receive(:new).with('vApp', :filter => "name==vapp-test-1").and_return(mock_query)
+          mock_query = double(:query)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_query)
+          mock_query.should_receive(:run).with('vApp', :filter => "name==vapp-test-1").and_return(q_results)
           obj = Vapp.get_by_name('vapp-test-1')
           expect(obj.class).to be(Vcloud::Core::Vapp)
         end
 
         it "should raise an error if no vApp with that name exists" do
           q_results = [ ]
-          mock_query = double(:query, :get_all_results => q_results)
-          Vcloud::Query.should_receive(:new).with('vApp', :filter => "name==vapp-test-1").and_return(mock_query)
+          mock_query = double(:query_runner)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_query)
+          mock_query.should_receive(:run).with('vApp', :filter => "name==vapp-test-1").and_return(q_results)
           expect{ Vapp.get_by_name('vapp-test-1') }.to raise_exception(RuntimeError)
         end
 
@@ -70,8 +72,9 @@ module Vcloud
             { :name => 'vapp-test-1', :href => @vapp_id },
             { :name => 'vapp-test-1', :href => '/bogus' },
           ]
-          mock_query = double(:query, :get_all_results => q_results)
-          Vcloud::Query.should_receive(:new).with('vApp', :filter => "name==vapp-test-1").and_return(mock_query)
+          mock_query = double(:query)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_query)
+          mock_query.should_receive(:run).with('vApp', :filter => "name==vapp-test-1").and_return(q_results)
           expect{ Vapp.get_by_name('vapp-test-1') }.to raise_exception(RuntimeError)
         end
 

data/spec/vcloud/core/vapp_template_spec.rb

@@ -50,10 +50,11 @@ module Vcloud
 
         it 'should raise a RuntimeError if there is no template' do
           q_results = [ ]
-          mock_query = double(:query, :get_all_results => q_results)
-          Vcloud::Query.should_receive(:new).
+          mock_query = double(:query_runner)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_query)
+          mock_query.should_receive(:run).
             with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
-            and_return(mock_query)
+            and_return(q_results)
           expect { VappTemplate.get('test_catalog', 'test_template') }.
             to raise_error('Could not find template vApp')
         end
@@ -65,10 +66,11 @@ module Vcloud
             { :name => 'test_template',
               :href => "/vappTemplate-12345678-90ab-cdef-0123-4567890ab002" },
           ]
-          mock_query = double(:query, :get_all_results => q_results)
-          Vcloud::Query.should_receive(:new).
+          mock_query = double(:query_runner)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_query)
+          mock_query.should_receive(:run).
             with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
-            and_return(mock_query)
+            and_return(q_results)
           expect { VappTemplate.get('test_catalog', 'test_template') }.
             to raise_error('Template test_template is not unique in catalog test_catalog')
         end
@@ -78,10 +80,11 @@ module Vcloud
             { :name => 'test_template',
               :href => "/vappTemplate-12345678-90ab-cdef-0123-4567890abcde" }
           ]
-          mock_query = double(:query, :get_all_results => q_results)
-          Vcloud::Query.should_receive(:new).
+          mock_query = double(:query)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_query)
+          mock_query.should_receive(:run).
             with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
-            and_return(mock_query)
+            and_return(q_results)
           test_template = VappTemplate.get('test_catalog', 'test_template')
           test_template.id.should == 'vappTemplate-12345678-90ab-cdef-0123-4567890abcde'
         end

data/spec/vcloud/core/vdc_spec.rb

@@ -46,16 +46,18 @@ module Vcloud
           q_results = [
             { :name => 'vdc-test-1', :href => @vdc_id }
           ]
-          mock_query = double(:query, :get_all_results => q_results)
-          Vcloud::Query.should_receive(:new).with('orgVdc', :filter => "name==vdc-test-1").and_return(mock_query)
+          mock_query = double(:query_runner)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_query)
+          mock_query.should_receive(:run).with('orgVdc', :filter => "name==vdc-test-1").and_return(q_results)
           obj = Vdc.get_by_name('vdc-test-1')
           expect(obj.class).to be(Vcloud::Core::Vdc)
         end
 
         it "should raise an error if no vDC with that name exists" do
           q_results = [ ]
-          mock_query = double(:query, :get_all_results => q_results)
-          Vcloud::Query.should_receive(:new).with('orgVdc', :filter => "name==vdc-test-1").and_return(mock_query)
+          mock_query = double(:query_runner)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_query)
+          mock_query.should_receive(:run).with('orgVdc', :filter => "name==vdc-test-1").and_return(q_results)
           expect{ Vdc.get_by_name('vdc-test-1') }.to raise_exception(RuntimeError, "vDc vdc-test-1 not found")
         end
 

data/spec/vcloud/core/vm_spec.rb

@@ -293,15 +293,19 @@ module Vcloud
           vdc_results = [
             { :vdcName => 'vdc-test-1' }
           ]
-          mock_vdc_query = double(:query, :get_all_results => vdc_results)
+          mock_vdc_query = double(:query_runner)
 
           storage_profile_results = [
             { :href => 'test-href' }
           ]
-          mock_sp_query = double(:query, :get_all_results => storage_profile_results)
+          mock_sp_query = double(:query_runner)
 
-          Vcloud::Query.should_receive(:new).with('vApp', :filter => "name==#{@vapp_name}").and_return(mock_vdc_query)
-          Vcloud::Query.should_receive(:new).with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").and_return(mock_sp_query)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_vdc_query)
+          mock_vdc_query.should_receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_sp_query)
+          mock_sp_query.should_receive(:run).
+            with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").
+            and_return(storage_profile_results)
 
           generated_storage_profile = { name: 'storage_profile_name', href: 'test-href' }
           @fog_interface.should_receive(:put_vm).with(@vm_id, @vm_name, { :StorageProfile => generated_storage_profile} ).and_return(true)
@@ -313,13 +317,17 @@ module Vcloud
           vdc_results = [
             { :vdcName => 'vdc-test-1' }
           ]
-          mock_vdc_query = double(:query, :get_all_results => vdc_results)
+          mock_vdc_query = double(:query_runner)
 
           storage_profile_results = []
-          mock_sp_query = double(:query, :get_all_results => storage_profile_results)
+          mock_sp_query = double(:query_runner)
 
-          Vcloud::Query.should_receive(:new).with('vApp', :filter => "name==#{@vapp_name}").and_return(mock_vdc_query)
-          Vcloud::Query.should_receive(:new).with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").and_return(mock_sp_query)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_vdc_query)
+          mock_vdc_query.should_receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_sp_query)
+          mock_sp_query.should_receive(:run).
+            with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").
+            and_return(storage_profile_results)
 
           expect{ @vm.update_storage_profile(storage_profile) }.to raise_error("storage profile not found" )
         end
@@ -329,13 +337,17 @@ module Vcloud
           vdc_results = [
             { :vdcName => 'vdc-test-1' }
           ]
-          mock_vdc_query = double(:query, :get_all_results => vdc_results)
+          mock_vdc_query = double(:query_runner)
 
           storage_profile_results = [ { :id => 'test-href'  }]
-          mock_sp_query = double(:query, :get_all_results => storage_profile_results)
-
-          Vcloud::Query.should_receive(:new).with('vApp', :filter => "name==#{@vapp_name}").and_return(mock_vdc_query)
-          Vcloud::Query.should_receive(:new).with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").and_return(mock_sp_query)
+          mock_sp_query = double(:query_runner)
+
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_vdc_query)
+          mock_vdc_query.should_receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
+          Vcloud::QueryRunner.should_receive(:new).and_return(mock_sp_query)
+          mock_sp_query.should_receive(:run).
+            with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").
+            and_return(storage_profile_results)
 
           expect{ @vm.update_storage_profile(storage_profile) }.to raise_error("storage profile not found" )
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vcloud-core
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-10 00:00:00.000000000 Z
+date: 2014-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
@@ -134,6 +134,7 @@ files:
 - lib/vcloud/core/metadata_helper.rb
 - lib/vcloud/core/org_vdc_network.rb
 - lib/vcloud/core/query.rb
+- lib/vcloud/core/query_runner.rb
 - lib/vcloud/core/vapp.rb
 - lib/vcloud/core/vapp_template.rb
 - lib/vcloud/core/vdc.rb
@@ -159,6 +160,7 @@ files:
 - spec/vcloud/core/edge_gateway_spec.rb
 - spec/vcloud/core/metadata_helper_spec.rb
 - spec/vcloud/core/org_vdc_network_spec.rb
+- spec/vcloud/core/query_runner_spec.rb
 - spec/vcloud/core/query_spec.rb
 - spec/vcloud/core/vapp_spec.rb
 - spec/vcloud/core/vapp_template_spec.rb
@@ -188,7 +190,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3857077396882591731
+      hash: 4238244327631333059
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -211,6 +213,7 @@ test_files:
 - spec/vcloud/core/edge_gateway_spec.rb
 - spec/vcloud/core/metadata_helper_spec.rb
 - spec/vcloud/core/org_vdc_network_spec.rb
+- spec/vcloud/core/query_runner_spec.rb
 - spec/vcloud/core/query_spec.rb
 - spec/vcloud/core/vapp_spec.rb
 - spec/vcloud/core/vapp_template_spec.rb