vagrant-skytap 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 42367c7e3c19aaeea00c74ed4756d8c54d92612f
-  data.tar.gz: c5b4962d7052fad5e4a7e4c90bad7799c64b92ed
+  metadata.gz: d2727c03689c62c012fa747457f85b6a24f667e5
+  data.tar.gz: 8d0a62aade129cb4532728e647b40129d8c44239
 SHA512:
-  metadata.gz: 3ac68aee81962e0729980aa6b5785413ca24780a2a149447f34ca3aec45a4cd4629c415035ff11c3acb838c69a85e5c115c47df2ea7ac24ded5655d0de8ed70c
-  data.tar.gz: a0fa8b2edc3ac422141d5af6d07990e18824c76443c649b2272ff0dab506124679b7fa401531e6ee215e38b5d14250a347b19d28c2c538e98ed3150190763799
+  metadata.gz: 5e11895205c8662c702d30d714bb3e89cdbf34f92671633720068855ce7eebe9305a13c437318e9f6b479e737d273dc91dc273950de745cd819d4e28fdbb9d8e
+  data.tar.gz: 962b89d9673a20560d54b942d068a64130c34de2e9434eeebe07017c9519189e31679ffc65f0e1fd2f830104a587dbee3c020473862a3cdbce2f48c649bc09ca

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.2.3 (January 28, 2016)
+
+* Optimizations to REST calls in `vagrant up`.
+
 # 0.2.2 (January 26, 2016)
 
 * Bug fix: `vagrant add` would create but not start a new VM if

data/lib/vagrant-skytap/action/add_vm_to_environment.rb

@@ -1,6 +1,5 @@
 require 'log4r'
-require 'json'
-require 'vagrant-skytap/setup_helper'
+require 'vagrant-skytap/api/vm'
 
 
 module VagrantPlugins
@@ -19,8 +18,9 @@ module VagrantPlugins
 
         def call(env)
           environment = env[:environment]
-          vm = environment.add_vm(vm_url)
-          env[:machine].id = vm.id
+          vm = API::Vm.fetch(env, vm_url)
+          environment.add_vms([vm])
+          env[:machine].id = environment.vms.last.id
           environment.wait_until_ready
 
           @app.call(env)

data/lib/vagrant-skytap/action/compose_environment.rb

@@ -0,0 +1,131 @@
+require 'log4r'
+require 'vagrant-skytap/api/environment'
+require 'vagrant-skytap/api/vm'
+
+module VagrantPlugins
+  module Skytap
+    module Action
+      # Creates a multi-VM Skytap environment, or adds VMs to an existing
+      # environment. The source VMs (analogous to "images") may come from
+      # various other environments and templates. We can parallelize this
+      # somewhat by adding multiple VMs per REST call, subject to the
+      # restriction that all source VMs added in a single call must be unique
+      # and must belong to the same containing environment/template.
+      # If creating a new environment from scratch, write the environment
+      # URL into the project data directory.
+      class ComposeEnvironment
+        attr_reader :env
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @logger = Log4r::Logger.new("vagrant_skytap::action::compose_environment")
+        end
+
+        def call(env)
+          environment = env[:environment]
+          new_environment = !environment
+          machines = env[:machines].reject(&:id)
+          environment = add_vms(environment, machines)
+
+          if new_environment
+            env[:environment] = environment
+            env[:ui].info(I18n.t("vagrant_skytap.environment_url", url: environment.url))
+          elsif machines.present?
+            env[:ui].info("Added VMs to #{environment.url}.")
+          else
+            env[:ui].info("No new VMs added to #{environment.url}.")
+          end
+
+          @app.call(env)
+        end
+
+        # Create Skytap VMs for the given machines (if they do not exist)
+        # within the given Skytap environment.
+        #
+        # @param [API::Environment] environment The Skytap environment, if it exists
+        # @param [Array] machines Set of [Vagrant::Machine] objects
+        # @return [API::Environment] The new or existing environment
+        def add_vms(environment, machines)
+          source_vms_map = fetch_source_vms(machines)
+
+          get_groupings(source_vms_map, parallel: @env[:parallel]).each do |names|
+            vms_for_pass = names.collect{|name| source_vms_map[name]}
+
+            if !environment
+              @logger.debug("Creating environment from source vms: #{vms_for_pass.collect(&:id)}")
+              environment = API::Environment.create!(env, vms_for_pass)
+              environment.properties.write('url' => environment.url)
+              vms = environment.vms
+            else
+              @logger.debug("Adding source vms: #{vms_for_pass.collect(&:id)}")
+              vms = environment.add_vms(vms_for_pass)
+            end
+
+            machines.select{|m| names.include?(m.name)}.each_with_index do |machine, i|
+              machine.id = vms[i].id
+            end
+          end
+
+          environment
+        end
+
+        # Fetch the source VMs for the given machines.
+        # TODO Optimize by downloading unique parent objects, and pick
+        # the VM child objects; Set the VMs' parent object so Vm#region
+        # doesn't require another GET.
+        #
+        # @param [Array] machines Set of [Vagrant::Machine] objects
+        # @return [Hash] mapping of machine names to [API::Vm] objects
+        def fetch_source_vms(machines)
+          machines.inject({}) do |acc, machine|
+            acc[machine.name] = API::Vm.fetch(env, machine.provider_config.vm_url)
+            acc
+          end
+        end
+
+        # Group the machines to minimize calls to the REST API --
+        # unique VMs from the same environment or template can be
+        # added in a single call. The return value is a nested
+        # array of machine names, e.g.:
+        # [ [:vm1, :vm4, :vm5], [:vm3], [:vm2] ]
+        #
+        # However, if the :parallel option is false, just return one
+        # machine per grouping, e.g.:
+        # [ [:vm1], [:vm2], [:vm3], [:vm4], [:vm5] ]
+        #
+        # @param [Hash] vms_map Mapping of machine names to [API::Vm] objects
+        # @param [Hash] options
+        # @return [Array] groupings (arrays) of machine names
+        def get_groupings(vms_map, options={})
+          parallel = true
+          parallel = options[:parallel] if options.has_key?(:parallel)
+          return vms_map.keys.collect{|name| [name]} unless parallel
+
+          # Produces nested hash, mapping configuration/template urls to
+          # a map of machine names to the source VM id. (We discard the
+          # parent urls -- they are just used to group the VMs.)
+          groupings = vms_map.inject(Hash.new{|h,k| h[k] = {}}) do |acc, (name, vm)|
+            acc[vm.parent_url][name] = vm.id
+            acc
+          end.values
+
+          # If the same source VM appears more than once, the API
+          # requires us to make multiple calls. For simplicity,
+          # if a particular grouping includes such, just create a single
+          # call for each vm in the group. (Could be optimized further)
+          groupings2 = []
+          groupings.each_with_index do |grouping, i|
+            if grouping.values.uniq.count == grouping.values.count
+              groupings2 << grouping.keys
+            else
+              groupings2.concat(grouping.keys.map{|v| [v]})
+            end
+          end
+
+          groupings2.sort_by{|grouping| grouping.count}.reverse
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/action/create_environment.rb

@@ -4,6 +4,7 @@ require 'json'
 require 'vagrant-skytap/setup_helper'
 require 'vagrant-skytap/util/timer'
 require 'vagrant-skytap/api/environment'
+require 'vagrant-skytap/api/vm'
 
 require 'net/https'
 require 'uri'
@@ -26,7 +27,8 @@ module VagrantPlugins
         end
 
         def call(env)
-          environment = API::Environment.create!(env, vm_url)
+          vm = API::Vm.fetch(env, vm_url)
+          environment = API::Environment.create!(env, [vm])
           env[:environment] = environment
           environment.properties.write('url' => environment.url)
           env[:machine].id = environment.vms.first.id

data/lib/vagrant-skytap/action/initialize_api_client.rb

@@ -13,11 +13,12 @@ module VagrantPlugins
         end
 
         def call(env)
-          @logger.info("Connecting to Skytap...")
-
-          client = API::Client.new(env[:machine].provider_config)
-          if client.get('/configurations').code == '200'
-            env[:api_client] = client
+          unless env[:api_client]
+            @logger.info("Connecting to Skytap...")
+            client = API::Client.new(env[:machine].provider_config)
+            if client.get('/configurations').code == '200'
+              env[:api_client] = client
+            end
           end
 
           @app.call(env)

data/lib/vagrant-skytap/action/set_up_vm.rb

@@ -12,7 +12,9 @@ module VagrantPlugins
         end
 
         def call(env)
-          SetupHelper.run!(env, env[:environment])
+          unless VmProperties.read(env[:machine].data_dir)
+            SetupHelper.run!(env, env[:environment])
+          end
           @app.call(env)
         end
       end

data/lib/vagrant-skytap/action/store_extra_data.rb

@@ -17,8 +17,10 @@ module VagrantPlugins
 
         def call(env)
           entry = machine_index_entry
-          entry.extra_data.merge!(provider_extra_data)
-          entry = machine_index.set(entry)
+          unless entry.extra_data.has_key?('vm_id')
+            entry.extra_data.merge!(provider_extra_data)
+            entry = machine_index.set(entry)
+          end
           machine_index.release(entry)
 
           @app.call(env)

data/lib/vagrant-skytap/action.rb

@@ -208,26 +208,14 @@ module VagrantPlugins
         Vagrant::Action::Builder.new.tap do |b|
           b.use HandleBox
           b.use action_fetch_environment
-          b.use Call, ExistenceCheck do |env, b1|
-            case result = env[:result]
-            when :missing_environment
-              b1.use CreateEnvironment
-              b1.use MessageEnvironmentUrl
-            when :no_vms, :missing_vm
-              b1.use AddVmToEnvironment
-            else
-              next
-            end
-            b1.use StoreExtraData
-            b1.use SetUpVm
-          end
+          b.use ComposeEnvironment
         end
       end
 
       def self.action_update_hardware
         Vagrant::Action::Builder.new.tap do |b|
-          b.use InitializeAPIClient
-          b.use FetchEnvironment
+          b.use StoreExtraData
+          b.use SetUpVm
           b.use Call, IsStopped do |env, b1|
             if env[:result]
               b1.use UpdateHardware
@@ -239,8 +227,6 @@ module VagrantPlugins
 
       def self.action_run_vm
         Vagrant::Action::Builder.new.tap do |b|
-          b.use InitializeAPIClient
-          b.use FetchEnvironment
 
           # The "up" command stores the pre-run states to
           # avoid a race condition when running multiple
@@ -314,6 +300,7 @@ module VagrantPlugins
       autoload :StoreExtraData, action_root.join("store_extra_data")
       autoload :AddVmToEnvironment, action_root.join("add_vm_to_environment")
       autoload :ClearForwardedPorts, action_root.join("clear_forwarded_ports")
+      autoload :ComposeEnvironment, action_root.join("compose_environment")
       autoload :CreateEnvironment, action_root.join("create_environment")
       autoload :DeleteEnvironment, action_root.join("delete_environment")
       autoload :DeleteVm, action_root.join("delete_vm")

data/lib/vagrant-skytap/api/environment.rb

@@ -16,11 +16,17 @@ module VagrantPlugins
 
         RESOURCE_ROOT = '/configurations'
         class << self
-          def create!(env, vm_url)
-            vm = Vm.fetch(env, vm_url)
-            check_vm_before_adding(env, vm)
-
-            args = {vm_ids: [vm.id]}.tap do |ret|
+          # Makes the REST call to create a new environment, using
+          # the provided VMs as sources.
+          #
+          # @param [Hash] env The environment hash passed in from the action
+          # @param [Array] vms The source [API::Vm] objects
+          # @return [API::Environment]
+          def create!(env, vms)
+            check_vms_before_adding(vms)
+            vm = vms.first
+
+            args = {vm_ids: vms.collect(&:id)}.tap do |ret|
               if vm.from_template?
                 ret[:template_id] = vm.template_id
               else
@@ -32,6 +38,11 @@ module VagrantPlugins
             new(JSON.load(resp.body), env)
           end
 
+          # Makes the REST call to retrieve an existing environment.
+          #
+          # @param [Hash] env The environment hash passed in from the action
+          # @param [String] url The url of the remote resource.
+          # @return [API::Environment]
           def fetch(env, url)
             resp = env[:api_client].get(url)
             new(JSON.load(resp.body), env)
@@ -41,16 +52,34 @@ module VagrantPlugins
             EnvironmentProperties.read(env[:machine].env.local_data_path)
           end
 
-          def check_vm_before_adding(env, vm)
-            raise Errors::SourceVmNotStopped, name: env[:machine].name, url: vm.url unless vm.stopped?
+          # Validates that a set of VMs can be used together in a REST call to
+          # create a new environment, or to add to an existing environment.
+          #
+          # @param [Array] vms The [API::Vm] objects to validate
+          # @param [API::Environment] environment to validate against (optional)
+          # @return [Boolean] true, if no exceptions were raised
+          def check_vms_before_adding(vms, environment = nil)
+            # logger.debug
+            vms.each do |vm|
+              raise Errors::SourceVmNotStopped, url: vm.url unless vm.stopped?
+            end
+
+            raise Errors::VmParentMismatch, vm_ids: vms.collect(&:id).join(', ') unless vms.collect(&:parent_url).uniq.count == 1
+
+            if environment
+              parent = vms.first.parent
+              unless parent.region == environment.region
+                raise Errors::RegionMismatch, environment_region: environment.region, vm_region: parent.region
+              end
+            end
+            true
           end
         end
 
-
         attr_reader :provider_config
         attr_reader :vms, :networks
 
-        reads :id, :name, :vms, :networks, :region, :runstate, :url
+        reads :id, :name, :vms, :networks, :region, :runstate, :url, :region
 
         def initialize(attrs, env)
           super
@@ -63,7 +92,7 @@ module VagrantPlugins
           end
         end
 
-        def get_vms_by_id(ids=[])
+        def get_vms_by_id(ids)
           vms.select{|vm| ids.include?(vm.id)}
         end
 
@@ -109,27 +138,26 @@ module VagrantPlugins
           end
         end
 
-        def add_vm(vm_url)
-          vm = Vm.fetch(env, vm_url)
-          check_vm_before_adding(env, vm)
-          vm_ids = vms.collect(&:id)
+        # Makes the REST call to add VMs to this environment, using
+        # the provided VMs as sources.
+        #
+        # @param [Array] vms The source [API::Vm] objects
+        # @return [Array] The new [API::Vm] objects
+        def add_vms(vms)
+          return unless vms.present?
+          self.class.check_vms_before_adding(vms, self)
 
-          args = {vm_ids: [vm.id]}.tap do |ret|
-            if vm.from_template?
-              ret[:template_id] = vm.template_id
+          args = {vm_ids: vms.collect(&:id)}.tap do |ret|
+            if vms.first.from_template?
+              ret[:template_id] = vms.first.template_id
             else
-              ret[:merge_configuration] = vm.configuration_id
+              ret[:merge_configuration] = vms.first.configuration_id
             end
           end
 
+          existing_vm_ids = self.vms.collect(&:id)
           update_with_retry(args)
-          new_vm_ids = vms.collect(&:id) - vm_ids
-          get_vm_by_id(new_vm_ids.last)
-        end
-
-        def check_vm_before_adding(env, vm)
-          raise Errors::RegionMismatch, environment_region: region, vm_region: vm.region unless vm.region == region
-          self.class.check_vm_before_adding(env, vm)
+          get_vms_by_id(self.vms.collect(&:id) - existing_vm_ids)
         end
 
         def create_publish_set(attrs={})

data/lib/vagrant-skytap/api/vm.rb

@@ -70,10 +70,16 @@ module VagrantPlugins
           $1
         end
 
+        def parent_url
+          template_url || configuration_url
+        end
+
+        def parent
+          @parent ||= Environment.fetch(env, parent_url)
+        end
+
         def region
-          return @region if @region
-          resp = env[:api_client].get(template_url || configuration_url)
-          @region = JSON.load(resp.body)['region']
+          @region ||= parent.region
         end
 
         def delete

data/lib/vagrant-skytap/command/up.rb

@@ -11,15 +11,6 @@ module VagrantPlugins
       class Up < VagrantPlugins::CommandUp::Command
 
         def execute
-          # This implementation of the "up" command overrides
-          # the default implementation due to load order.
-          if @env.default_provider == :skytap
-            @logger.debug("Executing Skytap 'Up' implementation.")
-          else
-            @logger.debug("Calling default 'Up' implementation.")
-            return super
-          end
-
           options = {}
           options[:destroy_on_error] = true
           options[:parallel] = true
@@ -80,28 +71,15 @@ module VagrantPlugins
             names = nil if autostart && names.empty?
           end
 
-          if names
-            with_target_vms(names, provider: options[:provider]) do |machine|
-              @env.ui.info(I18n.t(
-                "vagrant.commands.up.upping",
-                name: machine.name,
-                provider: machine.provider_name))
-
-              machines << machine
-              machine.action(:create, options)
-              machine.action(:update_hardware, options)
-            end
-
-            initial_states = machines.inject({}) {|acc, m| acc[m.id] = m.state.id ; acc }
-
-            machines.each do |machine|
-              machine.action(:run_vm, options.merge(
-                machines:       machines,
-                initial_states: initial_states
-              ))
-            end
+          with_target_vms(names, provider: options[:provider]) {|machine| machines << machine}
+          unless machines.first.provider_name == :skytap
+            @logger.debug("Calling default 'Up' implementation.")
+            return super
           end
 
+          @logger.debug("Executing Skytap 'Up' implementation.")
+          bring_up_machines(machines, options)
+
           if machines.empty?
             @env.ui.info(I18n.t("vagrant.up_no_machines"))
             return 0
@@ -124,8 +102,46 @@ module VagrantPlugins
           # Success, exit status 0
           0
         end
+
+        # Custom handling for Skytap environments. Creating and
+        # running happens in multiple phases:
+        # * Compose Skytap environment from groups of VMs, or
+        #   add groups of machines to an existing environment,
+        #   using optimal number of API calls.
+        # * Customize the VMs.
+        # * Run the VMs. If parallelized this happens with a
+        #   single API call.
+        #
+        # @param [Array] machines The [Vagrant::Machine] objects to bring up
+        # @param [Hash] options
+        # @return [Array] The [Vagrant::Machine] objects
+        def bring_up_machines(machines, options={})
+          return [] unless machines.present?
+
+          # Invoke once for the entire set of machines.
+          result = machines.first.action(:create, options.merge(machines: machines))
+
+          # Lets us eliminate some redundant API calls
+          cached_objects = {
+            api_client:     result[:api_client],
+            environment:    result[:environment],
+            machines:       machines,
+            initial_states: machines.inject({}) {|acc, m| acc[m.id] = m.state.id ; acc },
+          }
+
+          machines.each do |machine|
+            machine.action(:update_hardware, options.merge(cached_objects))
+          end
+
+          machines.each do |machine|
+            @env.ui.info(I18n.t(
+              "vagrant.commands.up.upping",
+              name: machine.name,
+              provider: machine.provider_name))
+            machine.action(:run_vm, options.merge(cached_objects))
+          end
+        end
       end
     end
   end
 end
-

data/lib/vagrant-skytap/errors.rb

@@ -70,6 +70,10 @@ module VagrantPlugins
       class FeatureNotSupportedForHostOs < VagrantSkytapError
         error_key(:feature_not_supported_for_host_os)
       end
+
+      class VmParentMismatch < VagrantSkytapError
+        error_key(:vm_parent_mismatch)
+      end
     end
   end
 end

data/lib/vagrant-skytap/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Skytap
-    VERSION = "0.2.2"
+    VERSION = "0.2.3"
   end
 end

data/locales/en.yml

@@ -85,7 +85,7 @@ en:
         Could not connect to the VPN.
 
       source_vm_not_stopped: |-
-        You cannot bring up the machine '%{name}' using the VM %{url} because the VM is running or suspended.
+        You cannot bring up the machine using the VM %{url} because the VM is running or suspended.
 
       resource_busy: |-
         This operation failed because the resource was busy: %{err}
@@ -109,6 +109,10 @@ en:
       region_mismatch: |-
         A VM from the '%{vm_region}' region cannot be added to an environment in the '%{environment_region}' region.
 
+      vm_parent_mismatch: |-
+        The provided VMs (%{vm_ids}) do not belong to the same environment or template.
+        (This is a bug which should be reported.)
+
       feature_not_supported_for_host_os: |-
         The %{feature_name} feature is currently not supported for your host operating system.
 

data/spec/unit/actions/compose_environment_spec.rb

@@ -0,0 +1,101 @@
+require File.expand_path("../../base", __FILE__)
+
+describe VagrantPlugins::Skytap::Action::ComposeEnvironment do
+  include_context "unit"
+  include_context "rest_api"
+
+  let(:app) { lambda { |env| } }
+  let(:env) { { machine: machine, machines: [machine], environment: environment, ui: ui, api_client: api_client } }
+  let(:base_url) {"http://example.com/"}
+  let(:provider_config) do
+    double(:provider_config, vm_url: "/vms/1", username: "jsmith", api_token: "123123", base_url: base_url)
+  end
+  let(:ui)         { double(:ui, info: nil) }
+  let(:api_client) { API::Client.new(provider_config) }
+
+  let(:machine)          { double(:machine, name: "vm1", id: nil, :id= => nil, provider_config: provider_config) }
+  let(:existing_machine) { double(:existing_machine, name: "vm2", id: 2) }
+
+  let(:environment)     { double(:environment, url: "foo") }
+  let(:new_environment) { double(:environment, url: "foo", vms: [vm], properties: environment_properties) }
+  let(:vm)              { double(:vm, id: 1, parent_url: "https://example.com/templates/1") }
+
+  let(:environment_properties) { double(:environment_properties, read: nil, write: nil) }
+
+  let(:subject) { described_class.new(app, env) }
+
+  before do
+    stub_request(:get, /.*/).to_return(body: '{}', status: 200)
+  end
+
+  describe "#call" do
+    it "does nothing if all machines exist" do
+      machine.stub(id: 1)
+      expect(app).to receive(:call).with(env)
+
+      expect(API::Environment).to_not receive(:create!)
+      expect(API::Vm).to_not receive(:fetch)
+      expect(environment).to_not receive(:add_vms)
+
+      subject.call(env)
+    end
+
+    it "makes a single create! call when creating an environment with 1 machine", run: true do
+      myenv = env.merge(environment: nil)
+      expect(app).to receive(:call).with(myenv)
+
+      expect(API::Environment).to receive(:create!).and_return(new_environment)
+      expect(API::Vm).to receive(:fetch).once.and_return(vm)
+      expect(environment).to_not receive(:add_vms)
+
+      subject.call(myenv)
+    end
+
+    it "makes a single add_vms call when adding 1 machine to existing environment" do
+      myenv = env.merge(machines: [machine, existing_machine])
+      expect(app).to receive(:call).with(myenv)
+
+      expect(API::Environment).to_not receive(:create!)
+      expect(API::Vm).to receive(:fetch).once.and_return(vm)
+      expect(environment).to receive(:add_vms).once.and_return([vm])
+
+      subject.call(myenv)
+    end
+  end
+
+  describe "fetch_source_vms" do
+    it "fetches a vm and returns a mapping" do
+      vms = subject.fetch_source_vms([machine])
+      expect(a_request(:get, %r{/vms/\d+$})).to have_been_made.once
+      expect(vms.count).to eq(1)
+      expect(vms.keys.first).to eq("vm1")
+      expect(vms.values.first).to be_a_kind_of(API::Vm)
+    end
+  end
+
+  describe "get_groupings" do
+    let(:vm_in_same_template)      { double(:vm_in_same_template,      id: 2, parent_url: "https://example.com/templates/1")}
+    let(:vm_in_different_template) { double(:vm_in_different_template, id: 3, parent_url: "https://example.com/templates/2")}
+
+    it "returns a single group for a single vm" do
+      expect(subject.get_groupings({"vm1" => vm})).to eq([ ["vm1"] ])
+    end
+
+    it "groups vms in same template together" do
+      expect(subject.get_groupings({"vm1" => vm, "vm2" => vm_in_same_template})).to eq([ ["vm1", "vm2"] ])
+    end
+
+    it "groups vms in different templates separately" do
+      # These are expected to be in reverse order, because we sort them descending by count
+      expect(subject.get_groupings({"vm1" => vm, "vm2" => vm_in_different_template})).to eq([ ["vm2"], ["vm1"] ])
+    end
+
+    it "groups identical vms separately" do
+      expect(subject.get_groupings({"vm1" => vm, "vm2" => vm})).to eq([ ["vm2"], ["vm1"] ])
+    end
+
+    it "respects parallel flag" do
+      expect(subject.get_groupings({"vm1" => vm, "vm2" => vm_in_same_template}, parallel: false)).to eq([ ["vm1"], ["vm2"] ])
+    end
+  end
+end