vagrant-skytap 0.1.1a

data/spec/unit/environment_spec.rb

@@ -0,0 +1,144 @@
+require_relative 'base'
+require "vagrant-skytap/api/environment"
+
+describe VagrantPlugins::Skytap::API::Environment do
+  include_context "unit"
+  Errors = VagrantPlugins::Skytap::Errors
+
+  let(:vm1_attrs) { JSON.load(File.read(File.join(File.expand_path('..', __FILE__), 'skeletons', 'vm1.json'))) }
+  let(:vm2_attrs) { vm1_attrs.merge("id" => "6981851", "name" => "VM2") }
+  let(:network1_attrs) { JSON.load(File.read(File.join(File.expand_path('..', __FILE__), 'skeletons', 'network1.json'))) }
+  let(:empty_environment_attrs) { JSON.load(File.read(File.join(File.expand_path('..', __FILE__), 'skeletons', 'empty_environment.json')))}
+
+  let(:attrs_one_vm) do
+    empty_environment_attrs.dup.tap do |ret|
+      ret['vms'] = [vm1_attrs]
+      ret['networks'] = [network1_attrs]
+    end
+  end
+
+  let(:attrs) do
+    attrs_one_vm.dup.tap do |ret|
+      ret['vms'] = [vm1_attrs, vm2_attrs]
+    end
+  end
+
+  let(:iso_env) do
+    # We have to create a Vagrantfile so there is a root path
+    env = isolated_environment
+    env.vagrantfile("")
+    env.create_vagrant_env
+  end
+
+  let(:machine)  { iso_env.machine(iso_env.machine_names[0], :dummy) }
+  let(:env)      {{ machine: machine }}
+  let(:instance) { described_class.new(attrs, env) }
+
+  let(:api_client) do
+    # By default, all GET requests will return an environment with VM1, VM2, and 1 network
+    double('api_client',
+      get: double('resp', body: JSON.dump(attrs))
+    )
+  end
+
+  # Ensure tests are not affected by Skytap credential environment variables
+  before :each do
+    ENV.stub(:[] => nil)
+  end
+
+  describe "check_vm_before_adding" do
+    subject do
+      instance.vms.first
+    end
+
+    it "raises SourceVmNotStopped if the vm is running" do
+      allow(subject).to receive(:runstate).and_return('running')
+      expect {described_class.check_vm_before_adding(env, subject)}.to raise_error(Errors::SourceVmNotStopped)
+      allow(subject).to receive(:runstate).and_call_original
+    end
+
+    it "raises SourceVmNotStopped if the vm is suspended" do
+      allow(subject).to receive(:runstate).and_return('suspended')
+      expect {described_class.check_vm_before_adding(env, subject)}.to raise_error(Errors::SourceVmNotStopped)
+      allow(subject).to receive(:runstate).and_call_original
+    end
+
+    it "raises nothing if the vm is stopped" do
+      allow(subject).to receive(:runstate).and_return('stopped')
+      expect {described_class.check_vm_before_adding(env, subject)}.to_not raise_error
+      allow(subject).to receive(:runstate).and_call_original
+    end
+  end
+
+  describe "vms" do
+    subject do
+      instance.vms.first
+    end
+    it { should be_a VagrantPlugins::Skytap::API::Vm }
+  end
+
+  describe "networks" do
+    subject do
+      instance.networks.first
+    end
+    it { should be_a VagrantPlugins::Skytap::API::Network }
+  end
+
+  describe "get_vm_by_id" do
+    subject do
+      instance
+    end
+
+    it "should return the appropriate vm from the collection" do
+      expect(subject.vms.count).to eq 2
+      expect(subject.get_vm_by_id('6981850').get_api_attribute('name')).to eq 'VM1'
+      expect(subject.get_vm_by_id('6981851').get_api_attribute('name')).to eq 'VM2'
+    end
+  end
+
+  describe "reload" do
+    subject do
+      old_attrs = attrs_one_vm.merge('networks' => [])
+      new_attrs = attrs.merge('name' => 'Environment with 2 vms')
+      client = double('api_client',
+        get: double('resp', body: JSON.dump(new_attrs))
+      )
+      myenv = env.merge(api_client: client)
+      described_class.new(old_attrs, myenv)
+    end
+
+    it "reloads the list of vms and networks" do
+      expect(subject.name).to eq 'Environment 1'
+      expect(subject.vms.count).to eq 1
+      expect(subject.networks.count).to eq 0
+      subject.reload
+      expect(subject.name).to eq 'Environment with 2 vms'
+      expect(subject.vms.count).to eq 2
+      expect(subject.networks.count).to eq 1
+    end
+  end
+
+  describe "busy?" do
+    subject do
+      instance
+    end
+
+    it "returns false when stopped" do
+      allow(subject).to receive(:runstate).and_return('stopped')
+      expect(subject.busy?).to eq false
+      allow(subject).to receive(:runstate).and_call_original
+    end
+
+    it "returns false when running" do
+      allow(subject).to receive(:runstate).and_return('running')
+      expect(subject.busy?).to eq false
+      allow(subject).to receive(:runstate).and_call_original
+    end
+
+    it "returns true when runstate is busy" do
+      allow(subject).to receive(:runstate).and_return('busy')
+      expect(subject.busy?).to eq true
+      allow(subject).to receive(:runstate).and_call_original
+    end
+  end
+end

data/spec/unit/skeletons/empty_environment.json

@@ -0,0 +1,19 @@
+{
+  "id": "5570024",
+  "url": "https://example.com/templates/5570024",
+  "name": "Environment 1",
+  "error": "",
+  "runstate": "running",
+  "description": "",
+  "suspend_on_idle": 86400,
+  "routable": false,
+  "vms": [],
+  "networks": [],
+  "lockversion": "60afa50045216f791278c10285a3a82bb1e4c5b8",
+  "use_smart_client": true,
+  "disable_internet": false,
+  "region": "US-West",
+  "region_backend": "skytap",
+  "owner": "https://example.com/users/15386",
+  "publish_sets": []
+}

data/spec/unit/skeletons/network1.json

@@ -0,0 +1,36 @@
+{
+  "id": "3288116",
+  "url": "https://example.com/templates/5570024/networks/3288116",
+  "name": "Default Network",
+  "network_type": "automatic",
+  "subnet": "10.0.0.0/24",
+  "subnet_addr": "10.0.0.0",
+  "subnet_size": 24,
+  "gateway": "10.0.0.254",
+  "primary_nameserver": null,
+  "secondary_nameserver": null,
+  "region": "US-West",
+  "domain": "skytap.example",
+  "vpn_attachments": [
+    {
+      "id": "3288116-vpn-711360",
+      "connected": true,
+      "network": {
+        "id": "3288116",
+        "subnet": "10.0.0.0/24",
+        "network_name": "Default Network",
+        "configuration_id": "5570024"
+      },
+      "vpn": {
+        "id": "vpn-711360",
+        "name": "Skytap sea9 NAT VPN",
+        "enabled": true,
+        "nat_enabled": true,
+        "remote_subnets": "10.1.0.0/24, 10.1.1.0/24, 10.1.2.0/24, 10.1.4.0/24, 10.1.6.0/24, 10.1.8.0/24, 10.1.16.0/24, 172.16.89.0/24, 192.168.0.0/16",
+        "remote_peer_ip": "66.193.98.66"
+      }
+    }
+  ],
+  "tunnelable": false,
+  "tunnels": []
+}

data/spec/unit/skeletons/vm1.json

@@ -0,0 +1,85 @@
+{
+  "id": "6981850",
+  "name": "VM1",
+  "runstate": "stopped",
+  "hardware": {
+    "cpus": 1,
+    "supports_multicore": true,
+    "cpus_per_socket": 1,
+    "ram": 1024,
+    "svms": 1,
+    "guestOS": "ubuntu-64",
+    "max_cpus": 12,
+    "min_ram": 256,
+    "max_ram": 131072,
+    "vnc_keymap": null,
+    "uuid": null,
+    "disks": [
+      {
+        "id": "disk-3089616-7086702-scsi-0-0",
+        "size": 20480,
+        "type": "SCSI",
+        "controller": "0",
+        "lun": "0"
+      }
+    ],
+    "storage": 20480,
+    "upgradable": false,
+    "instance_type": null,
+    "time_sync_enabled": true,
+    "copy_paste_enabled": true,
+    "nested_virtualization": false
+  },
+  "error": false,
+  "asset_id": null,
+  "hardware_version": 10,
+  "interfaces": [
+    {
+      "id": "nic-3089616-7086702-0",
+      "ip": "10.0.0.1",
+      "hostname": "host-1",
+      "mac": "00:50:56:14:34:E4",
+      "services_count": 0,
+      "services": [],
+      "public_ips_count": 0,
+      "public_ips": [],
+      "vm_id": "6981850",
+      "vm_name": "Ubuntu Server 14.04 - 64-bit",
+      "status": "Running",
+      "nat_addresses": {
+        "network_nat_addresses": [],
+        "vpn_nat_addresses": [
+          {
+            "ip_address": "10.1.130.104",
+            "vpn_id": "vpn-711360",
+            "vpn_name": "Skytap sea9 NAT VPN",
+            "vpn_url": "https://example.com/vpns/vpn-711360"
+          }
+        ]
+      },
+      "network_id": "3288116",
+      "network_name": "Default Network",
+      "network_url": "https://example.com/templates/5570024/networks/3288116",
+      "network_type": "automatic",
+      "network_subnet": "10.0.0.0/24",
+      "nic_type": "vmxnet3",
+      "promiscuous": false,
+      "secondary_ips": []
+    }
+  ],
+  "notes": [],
+  "labels": [],
+  "credentials": [
+    {
+      "id": "5695620",
+      "text": "skytap / ChangeMe!"
+    }
+  ],
+  "desktop_resizable": true,
+  "local_mouse_cursor": true,
+  "maintenance_lock_engaged": false,
+  "region_backend": "skytap",
+  "created_at": "2015/09/24 14:10:55 -0700",
+  "can_change_object_state": true,
+  "template_url": "https://example.com/templates/5570024"
+}

data/spec/unit/support/dummy_communicator.rb

@@ -0,0 +1,83 @@
+module VagrantTests
+  module DummyCommunicator
+    class Communicator < Vagrant.plugin("2", :communicator)
+      def ready?
+        true
+      end
+
+      attr_reader :known_commands
+
+      def initialize(machine)
+        @known_commands = Hash.new do |hash, key|
+          hash[key] = { expected: 0, received: 0, response: nil }
+        end
+      end
+
+      def expected_commands
+        known_commands.select do |command, info|
+          info[:expected] > 0
+        end
+      end
+
+      def received_commands
+        known_commands.select do |command, info|
+          info[:received] > 0
+        end.keys
+      end
+
+      def stub_command(command, response)
+        known_commands[command][:response] = response
+      end
+
+      def expect_command(command)
+        known_commands[command][:expected] += 1
+      end
+
+      def received_summary
+        received_commands.map { |cmd| " - #{cmd}" }.unshift('received:').join("\n")
+      end
+
+      def verify_expectations!
+        expected_commands.each do |command, info|
+          if info[:expected] != info[:received]
+            fail([
+              "expected to receive '#{command}' #{info[:expected]} times",
+              "got #{info[:received]} times instead",
+              received_summary
+            ].join("\n"))
+          end
+        end
+      end
+
+      def execute(command, opts=nil)
+        known = known_commands[command]
+        known[:received] += 1
+        response = known[:response]
+        return unless response
+
+        if block_given?
+          [:stdout, :stderr].each do |type|
+            Array(response[type]).each do |line|
+              yield type, line
+            end
+          end
+        end
+
+        if response[:raise]
+          raise response[:raise]
+        end
+
+        response[:exit_code]
+      end
+
+      def sudo(command, opts=nil, &block)
+        execute(command, opts, &block)
+      end
+
+      def test(command, opts=nil)
+        execute(command, opts) == 0
+      end
+    end
+  end
+end
+

data/spec/unit/support/dummy_provider.rb

@@ -0,0 +1,41 @@
+module VagrantTests
+  class DummyProviderPlugin < Vagrant.plugin("2")
+    name "Dummy Provider"
+    description <<-EOF
+    This creates a provider named "dummy" which does nothing, so that
+    the unit tests aren't reliant on VirtualBox (or any other real
+    provider for that matter).
+    EOF
+
+    provider(:dummy) { DummyProvider }
+  end
+
+  class DummyProvider < Vagrant.plugin("2", :provider)
+    def initialize(machine)
+      @machine = machine
+    end
+
+    def state=(id)
+      state_file.open("w+") do |f|
+        f.write(id.to_s)
+      end
+    end
+
+    def state
+      if !state_file.file?
+        new_state = @machine.id
+        new_state = Vagrant::MachineState::NOT_CREATED_ID if !new_state
+        self.state = new_state
+      end
+
+      state_id = state_file.read.to_sym
+      Vagrant::MachineState.new(state_id, state_id.to_s, state_id.to_s)
+    end
+
+    protected
+
+    def state_file
+      @machine.data_dir.join("dummy_state")
+    end
+  end
+end

data/spec/unit/support/isolated_environment.rb

@@ -0,0 +1,217 @@
+require "fileutils"
+require "pathname"
+require "tempfile"
+require "tmpdir"
+
+require "json"
+require "log4r"
+
+require "vagrant/util/platform"
+require "vagrant/util/subprocess"
+
+require "support/isolated_environment"
+
+module Unit
+  class IsolatedEnvironment < ::IsolatedEnvironment
+    def create_vagrant_env(options=nil)
+      options = {
+        cwd: @workdir,
+        home_path: @homedir
+      }.merge(options || {})
+
+      Vagrant::Environment.new(options)
+    end
+
+    # This creates a file in the isolated environment. By default this file
+    # will be created in the working directory of the isolated environment.
+    def file(name, contents)
+      @workdir.join(name).open("w+") do |f|
+        f.write(contents)
+      end
+    end
+
+    def vagrantfile(contents, root=nil)
+      root ||= @workdir
+      root.join("Vagrantfile").open("w+") do |f|
+        f.write(contents)
+      end
+    end
+
+    def box(name, vagrantfile_contents="")
+      # Create the box directory
+      box_dir = boxes_dir.join(name)
+      box_dir.mkpath
+
+      # Create the "box.ovf" file because that is how Vagrant heuristically
+      # determines a box is a V1 box.
+      box_dir.join("box.ovf").open("w") { |f| f.write("") }
+
+      # Populate the vagrantfile
+      vagrantfile(vagrantfile_contents, box_dir)
+
+      # Return the directory
+      box_dir
+    end
+
+    # Create an alias because "box" makes a V1 box, so "box1"
+    alias :box1 :box
+
+    # Creates a fake box to exist in this environment.
+    #
+    # @param [String] name Name of the box
+    # @param [Symbol] provider Provider the box was built for.
+    # @return [Pathname] Path to the box directory.
+    def box2(name, provider, options=nil)
+      # Default options
+      options = {
+        vagrantfile: ""
+      }.merge(options || {})
+
+      # Make the box directory
+      box_dir = boxes_dir.join(name, provider.to_s)
+      box_dir.mkpath
+
+      # Create a metadata.json file
+      box_metadata_file = box_dir.join("metadata.json")
+      box_metadata_file.open("w") do |f|
+        f.write(JSON.generate({
+          provider: provider.to_s
+        }))
+      end
+
+      # Create a Vagrantfile
+      box_vagrantfile = box_dir.join("Vagrantfile")
+      box_vagrantfile.open("w") do |f|
+        f.write(options[:vagrantfile])
+      end
+
+      # Return the box directory
+      box_dir
+    end
+
+    # Creates a fake box to exist in this environment according
+    # to the "gen-3" box format.
+    #
+    # @param [String] name
+    # @param [String] version
+    # @param [String] provider
+    # @return [Pathname]
+    def box3(name, version, provider, **opts)
+      # Create the directory for the box
+      box_dir = boxes_dir.join(name, version, provider.to_s)
+      box_dir.mkpath
+
+      # Create the metadata.json for it
+      box_metadata_file = box_dir.join("metadata.json")
+      box_metadata_file.open("w") do |f|
+        f.write(JSON.generate({
+          provider: provider.to_s
+        }))
+      end
+
+      # Create a Vagrantfile
+      if opts[:vagrantfile]
+        box_vagrantfile = box_dir.join("Vagrantfile")
+        box_vagrantfile.open("w") do |f|
+          f.write(opts[:vagrantfile])
+        end
+      end
+
+      # Create the metadata URL
+      if opts[:metadata_url]
+        boxes_dir.join(name, "metadata_url").open("w") do |f|
+          f.write(opts[:metadata_url])
+        end
+      end
+
+      box_dir
+    end
+
+    # This creates a "box" file that is a valid V1 box.
+    #
+    # @return [Pathname] Path to the newly created box.
+    def box1_file
+      # Create a temporary directory to store our data we will tar up
+      td_source = Dir.mktmpdir
+      td_dest   = Dir.mktmpdir
+
+      # Store the temporary directory so it is not deleted until
+      # this instance is garbage collected.
+      @_box2_file_temp ||= []
+      @_box2_file_temp << td_dest
+
+      # The source as a Pathname, which is easier to work with
+      source = Pathname.new(td_source)
+
+      # The destination file
+      result = Pathname.new(td_dest).join("temporary.box")
+
+      # Put a "box.ovf" in there.
+      source.join("box.ovf").open("w") do |f|
+        f.write("FOO!")
+      end
+
+      Dir.chdir(source) do
+        # Find all the files in our current directory and tar it up!
+        files = Dir.glob(File.join(".", "**", "*"))
+
+        # Package!
+        Vagrant::Util::Subprocess.execute("bsdtar", "-czf", result.to_s, *files)
+      end
+
+      # Resulting box
+      result
+    end
+
+    # This creates a "box" file with the given provider.
+    #
+    # @param [Symbol] provider Provider for the box.
+    # @return [Pathname] Path to the newly created box.
+    def box2_file(provider, options=nil)
+      options ||= {}
+
+      # This is the metadata we want to store in our file
+      metadata = {
+        "type"     => "v2_box",
+        "provider" => provider
+      }.merge(options[:metadata] || {})
+
+      # Create a temporary directory to store our data we will tar up
+      td_source = Dir.mktmpdir
+      td_dest   = Dir.mktmpdir
+
+      # Store the temporary directory so it is not deleted until
+      # this instance is garbage collected.
+      @_box2_file_temp ||= []
+      @_box2_file_temp << td_dest
+
+      # The source as a Pathname, which is easier to work with
+      source = Pathname.new(td_source)
+
+      # The destination file
+      result = Pathname.new(td_dest).join("temporary.box")
+
+      # Put the metadata.json in here.
+      source.join("metadata.json").open("w") do |f|
+        f.write(JSON.generate(metadata))
+      end
+
+      Dir.chdir(source) do
+        # Find all the files in our current directory and tar it up!
+        files = Dir.glob(File.join(".", "**", "*"))
+
+        # Package!
+        Vagrant::Util::Subprocess.execute("bsdtar", "-czf", result.to_s, *files)
+      end
+
+      # Resulting box
+      result
+    end
+
+    def boxes_dir
+      dir = @homedir.join("boxes")
+      dir.mkpath
+      dir
+    end
+  end
+end

data/spec/unit/support/shared/action_synced_folders_context.rb

@@ -0,0 +1,15 @@
+shared_context "synced folder actions" do
+  # This creates a synced folder implementation.
+  def impl(usable, name)
+    Class.new(Vagrant.plugin("2", :synced_folder)) do
+      define_method(:name) do
+        name
+      end
+
+      define_method(:usable?) do |machine, raise_error=false|
+        raise "#{name}: usable" if raise_error && !usable
+        usable
+      end
+    end
+  end
+end