foreman_fog_proxmox 0.12.2 → 0.13.3

data/test/unit/foreman_fog_proxmox/helpers/proxmox_vm_helper_test.rb

@@ -18,14 +18,14 @@
 # along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>.
 
 require 'test_plugin_helper'
-require 'fog/compute/proxmox/models/server'
-require 'fog/compute/proxmox/models/server_config'
-require 'fog/compute/proxmox/models/interface'
-require 'fog/compute/proxmox/models/interfaces'
-require 'fog/compute/proxmox/models/disk'
-require 'fog/compute/proxmox/models/disks'
-require 'fog/compute/proxmox/models/snapshots'
-require 'fog/compute/proxmox/models/tasks'
+require 'fog/proxmox/compute/models/server'
+require 'fog/proxmox/compute/models/server_config'
+require 'fog/proxmox/compute/models/interface'
+require 'fog/proxmox/compute/models/interfaces'
+require 'fog/proxmox/compute/models/disk'
+require 'fog/proxmox/compute/models/disks'
+require 'fog/proxmox/compute/models/snapshots'
+require 'fog/proxmox/compute/models/tasks'
 
 module ForemanFogProxmox
   class ProxmoxVmHelperTest < ActiveSupport::TestCase
@@ -39,7 +39,7 @@ module ForemanFogProxmox
         'vmid' => '100',
         'hostname' => 'test',
         :type => 'lxc',
-        :node_id => 'pve',
+        :node_id => 'proxmox',
         :service => service,
         'templated' => '0',
         'memory' => '536870912',
@@ -61,7 +61,7 @@ module ForemanFogProxmox
       Fog::Proxmox::Compute::Server.new(
         'vmid' => '100',
         'name' => 'test',
-        :node_id => 'pve',
+        :node_id => 'proxmox',
         :service => service,
         :type => 'qemu',
         'templated' => '0',
@@ -84,7 +84,7 @@ module ForemanFogProxmox
     let(:host_server) do
       { 'vmid' => '100',
         'name' => 'test',
-        'node_id' => 'pve',
+        'node_id' => 'proxmox',
         'type' => 'qemu',
         'config_attributes' => {
           'memory' => '536870912',
@@ -110,7 +110,7 @@ module ForemanFogProxmox
       { 'vmid' => '100',
         'name' => 'test',
         'type' => 'lxc',
-        'node_id' => 'pve',
+        'node_id' => 'proxmox',
         'ostemplate_storage' => 'local',
         'ostemplate_file' => 'local:vztmpl/alpine-3.7-default_20171211_amd64.tar.xz',
         'password' => 'proxmox01',
@@ -142,31 +142,33 @@ module ForemanFogProxmox
     describe 'object_to_config_hash' do
       setup { Fog.mock! }
       teardown { Fog.unmock! }
+      excluded_qemu_keys = ['templated', 'ide2', 'scsi0', 'net0', 'net1']
+      excluded_lxc_keys = ['templated', 'rootfs', 'mp0', 'net0', 'net1']
 
       it '#server qemu' do
-        config_hash = object_to_config_hash(server)
-        expected_config_hash = ActiveSupport::HashWithIndifferentAccess.new(server.config.attributes).reject { |key, _value| ['templated', 'ide2', 'scsi0', 'net0', 'net1'].include? key }
+        config_hash = object_to_config_hash(server, 'qemu')
+        expected_config_hash = ActiveSupport::HashWithIndifferentAccess.new(server.config.attributes).reject { |key, _value| excluded_qemu_keys.include? key }
         assert_equal expected_config_hash, config_hash['config_attributes']
       end
 
       it '#server lxc' do
-        config_hash = object_to_config_hash(server)
+        config_hash = object_to_config_hash(server, 'lxc')
         assert config_hash.key?('config_attributes')
-        expected_config_hash = ActiveSupport::HashWithIndifferentAccess.new(server.config.attributes).reject { |key, _value| ['templated', 'ide2', 'scsi0', 'net0', 'net1'].include? key }
+        expected_config_hash = ActiveSupport::HashWithIndifferentAccess.new(server.config.attributes).reject { |key, _value| excluded_qemu_keys.include? key }
         assert_equal expected_config_hash, config_hash['config_attributes']
       end
 
       it '#container qemu' do
-        config_hash = object_to_config_hash(container)
+        config_hash = object_to_config_hash(container, 'qemu')
         assert config_hash.key?('config_attributes')
-        expected_config_hash = ActiveSupport::HashWithIndifferentAccess.new(container.config.attributes).reject { |key, _value| ['templated', 'rootfs', 'mp0', 'net0', 'net1'].include? key }
+        expected_config_hash = ActiveSupport::HashWithIndifferentAccess.new(container.config.attributes).reject { |key, _value| excluded_lxc_keys.include? key }
         assert_equal expected_config_hash, config_hash['config_attributes']
       end
 
       it '#container lxc' do
-        config_hash = object_to_config_hash(container)
+        config_hash = object_to_config_hash(container, 'lxc')
         assert config_hash.key?('config_attributes')
-        expected_config_hash = ActiveSupport::HashWithIndifferentAccess.new(container.config.attributes).reject { |key, _value| ['templated', 'rootfs', 'mp0', 'net0', 'net1'].include? key }
+        expected_config_hash = ActiveSupport::HashWithIndifferentAccess.new(container.config.attributes).reject { |key, _value| excluded_lxc_keys.include? key }
         assert_equal expected_config_hash, config_hash['config_attributes']
       end
     end

data/test/unit/foreman_fog_proxmox/helpers/proxmox_vm_uuid_helper_test.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Tristan Robert
+
+# This file is part of ForemanFogProxmox.
+
+# ForemanFogProxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ForemanFogProxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>.
+
+require 'test_plugin_helper'
+
+module ForemanFogProxmox
+  class ProxmoxVmUuidHelperTest < ActiveSupport::TestCase
+    include ProxmoxVmUuidHelper
+
+    describe 'extract_vmid' do
+      setup { Fog.mock! }
+      teardown { Fog.unmock! }
+
+      it '#uuid=1_100 returns 100' do
+        assert_equal '100', extract_vmid('1_100')
+      end
+      it '#uuid=pve_100 returns ' do
+        assert_equal '', extract_vmid('pve_100')
+      end
+    end
+  end
+end

data/test/unit/foreman_fog_proxmox/helpers/proxmox_vm_volumes_helper_test.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Tristan Robert
+
+# This file is part of ForemanFogProxmox.
+
+# ForemanFogProxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ForemanFogProxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>.
+
+require 'test_plugin_helper'
+
+module ForemanFogProxmox
+  class ProxmoxVmVolumesHelperTest < ActiveSupport::TestCase
+    include ProxmoxVmVolumesHelper
+
+    describe 'remove_deletes' do
+      setup { Fog.mock! }
+      teardown { Fog.unmock! }
+      args = {
+        'volumes_attributes' => {
+          '0' => {
+            '_delete' => '',
+            'id' => 'scsi0',
+            'volid' => 'local-lvm:vm-100-disk',
+            'storage' => 'local-lvm',
+            'storage_type' => 'hard_disk'
+          }
+        }
+      }
+
+      it '# server volumes' do
+        remove_volume_keys(args)
+        assert args.key?('volumes_attributes')
+        assert args['volumes_attributes'].key?('0')
+        assert_not args['volumes_attributes']['0'].key?('_delete')
+        # assert_not args['volumes_attributes']['0'].key?('storage_type')
+      end
+    end
+  end
+end

data/test/unit/foreman_fog_proxmox/proxmox_compute_attributes_test.rb

@@ -61,7 +61,7 @@ module ForemanFogProxmox
       end
 
       it 'sets container hostname with host name' do
-        physical_nic = FactoryBot.build(:nic_base_empty, :identifier => 'net0', :primary => true, :compute_attributes => { 'dhcpv4' => '1', 'dhcpv6' => '1' })
+        physical_nic = FactoryBot.build(:nic_base_empty, :identifier => 'net0', :primary => true, :compute_attributes => { 'dhcp' => '1', 'dhcp6' => '1' })
         host = FactoryBot.build(
           :host_empty,
           :interfaces => [physical_nic],
@@ -84,23 +84,23 @@ module ForemanFogProxmox
       before do
         @cr = FactoryBot.build_stubbed(:proxmox_cr)
       end
+      excluded_keys = [:vmid, :disks, :interfaces]
 
       it 'converts a server to hash' do
         vm, config_attributes, volume_attributes, interface_attributes = mock_server_vm
         vm_attrs = @cr.vm_compute_attributes(vm)
         assert_not vm_attrs.key?(:config)
         assert vm_attrs.key?(:config_attributes)
-        assert_equal config_attributes.reject { |key, value| [:vmid, :disks, :interfaces].include?(key) || value.to_s.empty? }, vm_attrs[:config_attributes]
+        assert_equal config_attributes.reject { |key, value| excluded_keys.include?(key) || value.to_s.empty? }, vm_attrs[:config_attributes]
         assert_not vm_attrs[:config_attributes].key?(:disks)
         assert vm_attrs.key?(:volumes_attributes)
         assert_equal volume_attributes, vm_attrs[:volumes_attributes]['0']
         assert_not vm_attrs[:config_attributes].key?(:interfaces)
         assert vm_attrs.key?(:interfaces_attributes)
         assert_equal interface_attributes[:id], vm_attrs[:interfaces_attributes]['0'][:id]
-        assert_equal interface_attributes[:id], vm_attrs[:interfaces_attributes]['0'][:identifier]
-        assert_equal interface_attributes[:macaddr], vm_attrs[:interfaces_attributes]['0'][:mac]
-        assert_equal interface_attributes[:model], vm_attrs[:interfaces_attributes]['0'][:compute_attributes][:model]
-        assert_equal interface_attributes[:bridge], vm_attrs[:interfaces_attributes]['0'][:compute_attributes][:bridge]
+        assert_equal interface_attributes[:mac], vm_attrs[:interfaces_attributes]['0'][:compute_attributes][:macaddr]
+        assert_equal interface_attributes[:compute_attributes][:model], vm_attrs[:interfaces_attributes]['0'][:compute_attributes][:model]
+        assert_equal interface_attributes[:compute_attributes][:bridge], vm_attrs[:interfaces_attributes]['0'][:compute_attributes][:bridge]
       end
 
       it 'converts a container to hash' do
@@ -108,16 +108,15 @@ module ForemanFogProxmox
         vm_attrs = @cr.vm_compute_attributes(vm)
         assert_not vm_attrs.key?(:config)
         assert vm_attrs.key?(:config_attributes)
-        assert_equal config_attributes.reject { |key, value| [:vmid, :disks, :interfaces].include?(key) || value.to_s.empty? }, vm_attrs[:config_attributes]
+        assert_equal config_attributes.reject { |key, value| excluded_keys.include?(key) || value.to_s.empty? }, vm_attrs[:config_attributes]
         assert_not vm_attrs[:config_attributes].key?(:disks)
         assert vm_attrs.key?(:volumes_attributes)
         assert_equal volume_attributes, vm_attrs[:volumes_attributes]['0']
         assert vm_attrs.key?(:interfaces_attributes)
         assert_equal interface_attributes[:id], vm_attrs[:interfaces_attributes]['0'][:id]
-        assert_equal interface_attributes[:id], vm_attrs[:interfaces_attributes]['0'][:identifier]
-        assert_equal interface_attributes[:name], vm_attrs[:interfaces_attributes]['0'][:compute_attributes][:name]
-        assert_equal interface_attributes[:mac], vm_attrs[:interfaces_attributes]['0'][:compute_attributes][:mac]
-        assert_equal interface_attributes[:bridge], vm_attrs[:interfaces_attributes]['0'][:compute_attributes][:bridge]
+        assert_equal interface_attributes[:compute_attributes][:name], vm_attrs[:interfaces_attributes]['0'][:compute_attributes][:name]
+        assert_equal interface_attributes[:mac], vm_attrs[:interfaces_attributes]['0'][:compute_attributes][:hwaddr]
+        assert_equal interface_attributes[:compute_attributes][:bridge], vm_attrs[:interfaces_attributes]['0'][:compute_attributes][:bridge]
       end
     end
   end

data/test/unit/foreman_fog_proxmox/proxmox_interfaces_test.rb

@@ -46,10 +46,11 @@ module ForemanFogProxmox
         assert err.message.end_with?('Invalid identifier interface[0]. Must be net[n] with n integer >= 0')
       end
 
-      it 'sets server compute id with identifier, ip and ip6' do
+      it 'sets server compute id with identifier, ip and ip6 and mac adress' do
         ip = '192.168.56.100'
+        mac_address = '36:25:8C:53:0C:50'
         ip6 = Array.new(4) { format('%<x>s', x: rand(16**4)) }.join(':') + '::1'
-        physical_nic = FactoryBot.build(:nic_base_empty, :identifier => 'net0', :ip => ip, :ip6 => ip6)
+        physical_nic = FactoryBot.build(:nic_base_empty, :identifier => 'net0', :ip => ip, :ip6 => ip6, :mac => mac_address)
         host = FactoryBot.build(
           :host_empty,
           :interfaces => [physical_nic],
@@ -65,13 +66,14 @@ module ForemanFogProxmox
         assert_equal 'net0', nic_attr[:id]
         assert_equal ip, nic_attr[:ip]
         assert_equal ip6, nic_attr[:ip6]
+        assert_equal mac_address, nic_attr[:macaddr]
       end
 
       it 'sets container compute id with identifier, ip/CIDR, gw and ip6' do
         ip = '192.168.56.100'
-        cidr_suffix = '31'
+        cidr = '31'
         ip6 = Array.new(4) { format('%<x>s', x: rand(16**4)) }.join(':') + '::1'
-        physical_nic = FactoryBot.build(:nic_base_empty, :identifier => 'net0', :ip => ip, :ip6 => ip6, :compute_attributes => { 'cidrv4_prefix' => cidr_suffix, 'gwv4' => ip, 'dhcpv6' => '1' })
+        physical_nic = FactoryBot.build(:nic_base_empty, :identifier => 'net0', :ip => ip, :ip6 => ip6, :compute_attributes => { 'cidr' => cidr, 'gw' => ip, 'ip' => ip, 'dhcp6' => '1' })
         host = FactoryBot.build(
           :host_empty,
           :interfaces => [physical_nic],
@@ -85,16 +87,16 @@ module ForemanFogProxmox
         nic_attributes = @cr.host_interfaces_attrs(host).values.select(&:present?)
         nic_attr = nic_attributes.first
         assert_equal 'net0', nic_attr[:id]
-        assert_equal Fog::Proxmox::IpHelper.to_cidr(ip, cidr_suffix), nic_attr[:ip]
-        assert_equal ip, nic_attr[:gw]
+        assert_equal Fog::Proxmox::IpHelper.to_cidr(ip, cidr), nic_attr[:ip]
+        assert_equal ip, nic_attr['gw']
         assert_equal 'dhcp', nic_attr[:ip6]
       end
 
       it 'sets container compute id with identifier, ip DHCP, gw6 and ip6' do
         ip = '192.168.56.100'
-        cidr6_suffix = '100'
+        cidr6 = '100'
         ip6 = '2001:0:1234::c1c0:abcd:876'
-        physical_nic = FactoryBot.build(:nic_base_empty, :identifier => 'net0', :ip => ip, :ip6 => ip6, :compute_attributes => { 'cidrv6_prefix' => cidr6_suffix, 'dhcpv4' => '1', 'gwv6' => ip6 })
+        physical_nic = FactoryBot.build(:nic_base_empty, :identifier => 'net0', :ip => ip, :ip6 => ip6, :compute_attributes => { 'cidr6' => cidr6, 'dhcp' => '1', 'gw6' => ip6 })
         host = FactoryBot.build(
           :host_empty,
           :interfaces => [physical_nic],
@@ -109,8 +111,34 @@ module ForemanFogProxmox
         nic_attr = nic_attributes.first
         assert_equal 'net0', nic_attr[:id]
         assert_equal 'dhcp', nic_attr[:ip]
-        assert_equal Fog::Proxmox::IpHelper.to_cidr6(ip6, cidr6_suffix), nic_attr[:ip6]
-        assert_equal ip6, nic_attr[:gw6]
+        assert_equal Fog::Proxmox::IpHelper.to_cidr6(ip6, cidr6), nic_attr[:ip6]
+        assert_equal ip6, nic_attr['gw6']
+      end
+
+      it 'sets container compute id with identifier, ip DHCP, mac adress and firewall' do
+        ip = '192.168.56.100'
+        mac_address = '36:25:8C:53:0C:50'
+        ip6 = '2001:0:1234::c1c0:abcd:876'
+        firewall = '1'
+        compute_attributes = { 'dhcp' => '1', 'ip6' => ip6, 'firewall' => firewall }
+        physical_nic = FactoryBot.build(:nic_base_empty, :identifier => 'net0', :ip => ip, :ip6 => ip6, :mac => mac_address, :compute_attributes => compute_attributes)
+        host = FactoryBot.build(
+          :host_empty,
+          :interfaces => [physical_nic],
+          :compute_attributes => {
+            'type' => 'lxc',
+            'interfaces_attributes' => {
+              '0' => physical_nic
+            }
+          }
+        )
+        nic_attributes = @cr.host_interfaces_attrs(host).values.select(&:present?)
+        nic_attr = nic_attributes.first
+        assert_equal 'net0', nic_attr[:id]
+        assert_equal 'dhcp', nic_attr[:ip]
+        assert_equal mac_address, nic_attr[:hwaddr]
+        assert_equal ip6, nic_attr[:ip6]
+        assert_equal firewall, nic_attr['firewall']
       end
     end
   end

data/test/unit/foreman_fog_proxmox/proxmox_version_test.rb

@@ -26,11 +26,11 @@ module ForemanFogProxmox
     include ComputeResourceTestHelpers
     include ProxmoxVmHelper
 
-    wrong_version = { version: '5.a', release: '1' }.with_indifferent_access
-    supported_version = { version: '5.4', release: '3' }.with_indifferent_access
-    supported_6_version = { version: '6.0', release: '1' }.with_indifferent_access
-    supported_6_1_version = { version: '6.1', release: '3' }.with_indifferent_access
-    unsupported_version = { version: '5.2', release: '2' }.with_indifferent_access
+    wrong_version = { version: '5.a', release: '5.a-1' }.with_indifferent_access
+    supported_version = { version: '5.4', release: '5.4-3' }.with_indifferent_access
+    supported_6_version = { version: '6.0', release: '6.0-1' }.with_indifferent_access
+    supported_6_1_version = { version: '6.1', release: '6.1-3' }.with_indifferent_access
+    unsupported_version = { version: '5.2', release: '5.2-2' }.with_indifferent_access
 
     describe 'version' do
       before do
@@ -41,17 +41,17 @@ module ForemanFogProxmox
 
       it 'returns 5.a.1 with 5.a-1' do
         @identity_client.stubs(:read_version).returns(wrong_version)
-        assert_equal '5.a.1', @cr.version
+        assert_equal '5.a', @cr.version
       end
 
       it 'returns 5.4.3 with 5.4-3' do
         @identity_client.stubs(:read_version).returns(supported_version)
-        assert_equal '5.4.3', @cr.version
+        assert_equal '5.4', @cr.version
       end
 
       it 'returns 5.2.2 with 5.2-2' do
         @identity_client.stubs(:read_version).returns(unsupported_version)
-        assert_equal '5.2.2', @cr.version
+        assert_equal '5.2', @cr.version
       end
     end
 
@@ -62,12 +62,12 @@ module ForemanFogProxmox
         @cr.stubs(:identity_client).returns(@identity_client)
       end
 
-      it 'raises error with 5.a.1' do
+      it 'raises error with 5.a' do
         @identity_client.stubs(:read_version).returns(wrong_version)
         err = assert_raises Foreman::Exception do
           @cr.version_suitable?
         end
-        assert err.message.end_with?('Proxmox version 5.a.1 is not semver suitable')
+        assert err.message.end_with?('Proxmox version 5.a is not semver suitable')
       end
 
       it 'is true with 5.4-3' do

data/test/unit/foreman_fog_proxmox/proxmox_vm_commands_container_test.rb

@@ -43,10 +43,11 @@ module ForemanFogProxmox
         vm.stubs(:config).returns(config)
         vm.stubs(:container?).returns(true)
         vm.stubs(:type).returns('lxc')
-        vm.stubs(:node_id).returns('pve')
+        vm.stubs(:node_id).returns('proxmox')
+        vm.stubs(:attributes).returns(node_id: 'proxmox', type: 'lxc')
         @cr.stubs(:find_vm_by_uuid).returns(vm)
-        attr = { 'templated' => '0', 'node_id' => 'pve', 'config_attributes' => { 'cores' => '1', 'cpulimit' => '1', 'onboot' => '0' } }.with_indifferent_access
-        @cr.stubs(:parse_container_vm).returns('vmid' => '100', 'node_id' => 'pve2', 'type' => 'lxc', 'cores' => '1', 'cpulimit' => '1')
+        attr = { 'templated' => '0', 'node_id' => 'proxmox', 'config_attributes' => { 'cores' => '1', 'cpulimit' => '1', 'onboot' => '0' } }.with_indifferent_access
+        @cr.stubs(:parse_container_vm).returns('vmid' => '100', 'node_id' => 'proxmox2', 'type' => 'lxc', 'cores' => '1', 'cpulimit' => '1')
         expected_attr = { :cores => '1', :cpulimit => '1' }
         vm.expects(:update, expected_attr)
         @cr.save_vm(uuid, attr)
@@ -60,10 +61,11 @@ module ForemanFogProxmox
         vm.stubs(:config).returns(config)
         vm.stubs(:container?).returns(true)
         vm.stubs(:type).returns('lxc')
-        vm.stubs(:node_id).returns('pve')
+        vm.stubs(:node_id).returns('proxmox')
+        vm.stubs(:attributes).returns(node_id: 'proxmox', type: 'lxc')
         @cr.stubs(:find_vm_by_uuid).returns(vm)
-        attr = { 'templated' => '0', 'node_id' => 'pve', 'config_attributes' => { 'cores' => '1', 'cpulimit' => '1', 'onboot' => '0' } }.with_indifferent_access
-        @cr.stubs(:parse_container_vm).returns('vmid' => '100', 'node_id' => 'pve', 'type' => 'lxc', 'cores' => '1', 'cpulimit' => '1')
+        attr = { 'templated' => '0', 'node_id' => 'proxmox', 'config_attributes' => { 'cores' => '1', 'cpulimit' => '1', 'onboot' => '0' } }.with_indifferent_access
+        @cr.stubs(:parse_container_vm).returns('vmid' => '100', 'node_id' => 'proxmox', 'type' => 'lxc', 'cores' => '1', 'cpulimit' => '1')
         expected_attr = { :cores => '1', :cpulimit => '1' }
         vm.expects(:update, expected_attr)
         @cr.save_vm(uuid, attr)
@@ -81,14 +83,16 @@ module ForemanFogProxmox
         config.stubs(:disks).returns(disks)
         config.stubs(:attributes).returns(:cores => '')
         vm = mock('vm')
+        vm.stubs(:identity).returns(uuid)
         vm.stubs(:config).returns(config)
         vm.stubs(:container?).returns(true)
         vm.stubs(:type).returns('lxc')
-        vm.stubs(:node_id).returns('pve')
+        vm.stubs(:node_id).returns('proxmox')
+        vm.stubs(:attributes).returns(node_id: 'proxmox', type: 'lxc')
         @cr.stubs(:find_vm_by_uuid).returns(vm)
         new_attributes = {
           'templated' => '0',
-          'node_id' => 'pve',
+          'node_id' => 'proxmox',
           'config_attributes' => {
             'cores' => '1',
             'cpulimit' => '1'
@@ -105,7 +109,7 @@ module ForemanFogProxmox
             }
           }
         }.with_indifferent_access
-        @cr.stubs(:parse_container_vm).returns('vmid' => '100', 'node_id' => 'pve', 'type' => 'lxc', 'cores' => '1', 'cpulimit' => '1')
+        @cr.stubs(:parse_container_vm).returns('vmid' => '100', 'node_id' => 'proxmox', 'type' => 'lxc', 'cores' => '1', 'cpulimit' => '1')
         expected_config_attr = { :cores => '1', :cpulimit => '1' }
         expected_volume_attr =
           [
@@ -131,19 +135,22 @@ module ForemanFogProxmox
         disk.stubs(:size).returns(1_073_741_824)
         disk.stubs(:storage).returns('local-lvm')
         disk.stubs(:id).returns('rootfs')
+        disk.stubs(:attributes).returns(id: 'rootfs', storage: 'local-lvm', size: 1_073_741_824)
         disks.stubs(:get).returns(disk)
         config.stubs(:disks).returns(disks)
         config.stubs(:attributes).returns(:cores => '')
         vm = mock('vm')
+        vm.stubs(:identity).returns(uuid)
         vm.stubs(:config).returns(config)
         vm.stubs(:container?).returns(true)
         vm.stubs(:type).returns('lxc')
-        vm.stubs(:node_id).returns('pve')
+        vm.stubs(:node_id).returns('proxmox')
+        vm.stubs(:attributes).returns(node_id: 'proxmox', type: 'lxc', 'rootfs' => '')
         @cr.stubs(:find_vm_by_uuid).returns(vm)
         new_attributes =
           {
             'templated' => '0',
-            'node_id' => 'pve',
+            'node_id' => 'proxmox',
             'config_attributes' => {
               'cores' => '1',
               'cpulimit' => '1',
@@ -163,7 +170,7 @@ module ForemanFogProxmox
           }.with_indifferent_access
         @cr.stubs(:parse_container_vm).returns(
           'vmid' => '100',
-          'node_id' => 'pve',
+          'node_id' => 'proxmox',
           'type' => 'lxc',
           'cores' => '1',
           'cpulimit' => '1'
@@ -185,18 +192,21 @@ module ForemanFogProxmox
         disk.stubs(:id).returns('mp0')
         disk.stubs(:size).returns(1_073_741_824)
         disk.stubs(:storage).returns('local-lvm')
+        disk.stubs(:attributes).returns(id: 'mp0', storage: 'local-lvm', size: 1_073_741_824, volid: 'local-lvm:vm-100-disk-0')
         disks.stubs(:get).returns(disk)
         config.stubs(:disks).returns(disks)
         config.stubs(:attributes).returns(:cores => '')
         vm = mock('vm')
+        vm.stubs(:identity).returns(uuid)
         vm.stubs(:config).returns(config)
         vm.stubs(:container?).returns(true)
         vm.stubs(:type).returns('lxc')
-        vm.stubs(:node_id).returns('pve')
+        vm.stubs(:node_id).returns('proxmox')
+        vm.stubs(:attributes).returns(node_id: 'proxmox', type: 'lxc')
         @cr.stubs(:find_vm_by_uuid).returns(vm)
         new_attributes = {
           'templated' => '0',
-          'node_id' => 'pve',
+          'node_id' => 'proxmox',
           'config_attributes' => {
             'cores' => '1',
             'cpulimit' => '1'
@@ -214,7 +224,7 @@ module ForemanFogProxmox
             }
           }
         }.with_indifferent_access
-        @cr.stubs(:parse_server_vm).returns('vmid' => '100', 'node_id' => 'pve', 'type' => 'qemu', 'cores' => '1', 'cpulimit' => '1')
+        @cr.stubs(:parse_typed_vm).returns('vmid' => '100', 'node_id' => 'proxmox', 'type' => 'qemu', 'cores' => '1', 'cpulimit' => '1')
         expected_config_attr = { :cores => '1', :cpulimit => '1' }
         expected_volume_attr = { :id => 'mp0', :volid => 'local-lvm:vm-100-disk-0', :size => 1_073_741_824 }, { :mp => '/opt/toto' }
         vm.expects(:attach, expected_volume_attr)
@@ -225,44 +235,44 @@ module ForemanFogProxmox
 
     describe 'create_vm' do
       it 'creates container without bootstart' do
-        args = { vmid: '100', type: 'lxc', node_id: 'pve', start_after_create: '0' }
+        args = { vmid: '100', type: 'lxc', node_id: 'proxmox', start_after_create: '0' }
         servers = mock('servers')
         servers.stubs(:id_valid?).returns(true)
         containers = mock('containers')
-        containers.stubs(:create).with(vmid: 100, type: 'lxc', node_id: 'pve', start_after_create: '0')
+        containers.stubs(:create).with(args)
         cr = mock_node_servers_containers(ForemanFogProxmox::Proxmox.new, servers, containers)
         cr.stubs(:convert_sizes).with(args)
-        cr.stubs(:parse_container_vm).with(args).returns(args)
+        cr.stubs(:parse_typed_vm).with(args, 'lxc').returns(args)
         vm = mock('vm')
         cr.stubs(:find_vm_by_uuid).with((args[:vmid]).to_s).returns(vm)
         cr.create_vm(args)
       end
 
       it 'creates container with bootstart' do
-        args = { vmid: '100', type: 'lxc', node_id: 'pve', start_after_create: '1' }
+        args = { vmid: '100', type: 'lxc', node_id: 'proxmox', start_after_create: '1' }
         servers = mock('servers')
         servers.stubs(:id_valid?).returns(true)
         containers = mock('containers')
         vm = mock('vm')
-        containers.stubs(:create).with(vmid: 100, type: 'lxc', node_id: 'pve', start_after_create: '1').returns(vm)
+        containers.stubs(:create).with(args).returns(vm)
         cr = mock_node_servers_containers(ForemanFogProxmox::Proxmox.new, servers, containers)
         cr.stubs(:convert_sizes).with(args)
-        cr.stubs(:parse_container_vm).with(args).returns(args)
+        cr.stubs(:parse_typed_vm).with(args, 'lxc').returns(args)
         cr.stubs(:find_vm_by_uuid).with((args[:vmid]).to_s).returns(vm)
         cr.stubs(:start_on_boot).with(vm, args).returns(vm)
         cr.create_vm(args)
       end
 
       it 'creates container within pool' do
-        args = { vmid: '100', type: 'lxc', node_id: 'pve', start_after_create: '0', pool: 'pool1' }
+        args = { vmid: '100', type: 'lxc', node_id: 'proxmox', start_after_create: '0', pool: 'pool1' }
         servers = mock('servers')
         servers.stubs(:id_valid?).returns(true)
         containers = mock('containers')
         vm = mock('vm')
-        containers.stubs(:create).with(vmid: 100, type: 'lxc', node_id: 'pve', start_after_create: '0', pool: 'pool1').returns(vm)
+        containers.stubs(:create).with(args).returns(vm)
         cr = mock_node_servers_containers(ForemanFogProxmox::Proxmox.new, servers, containers)
         cr.stubs(:convert_sizes).with(args)
-        cr.stubs(:parse_container_vm).with(args).returns(args)
+        cr.stubs(:parse_typed_vm).with(args, 'lxc').returns(args)
         cr.stubs(:find_vm_by_uuid).with((args[:vmid]).to_s).returns(vm)
         cr.create_vm(args)
       end