Project

General

Profile

Download (49 KB) Statistics
| Branch: | Tag: | Revision:

foreman/test/controllers/api/v2/hosts_controller_test.rb @ d5f2f1de

0fda4cf6 Joseph Mitchell Magen
require 'test_helper'
ea98080f Dominic Cleal
require 'controllers/shared/pxe_loader_test'
0fda4cf6 Joseph Mitchell Magen
class Api::V2::HostsControllerTest < ActionController::TestCase
4cbf879e Lukas Zapletal
include ::PxeLoaderTest
c7c53aeb Shimon Shtein
include FactImporterIsolation

allow_transactions_for_any_importer
4cbf879e Lukas Zapletal
e14b5758 Greg Sutcliffe
def setup
8dcc90be Marek Hulán
as_admin do
8c6bc83e Marek Hulan
@host = FactoryBot.create(:host)
@ptable = FactoryBot.create(:ptable)
8dcc90be Marek Hulán
@ptable.operatingsystems = [ Operatingsystem.find_by_name('Redhat') ]
end
e14b5758 Greg Sutcliffe
end

cfd1c413 Tomas Strachota
def basic_attrs
dc38aad3 Joseph Magen
{ :name => 'testhost11',
:environment_id => environments(:production).id,
:domain_id => domains(:mydomain).id,
510d53cd Marek Hulan
:ptable_id => @ptable.id,
6568415c Joseph Magen
:medium_id => media(:one).id,
dc38aad3 Joseph Magen
:architecture_id => Architecture.find_by_name('x86_64').id,
:operatingsystem_id => Operatingsystem.find_by_name('Redhat').id,
4693fe5f Ondrej Prazak
:puppet_proxy_id => smart_proxies(:puppetmaster).id,
c4bfd47f Stephen Benjamin
:compute_resource_id => compute_resources(:one).id,
160e24ea Joseph Magen
:root_pass => "xybxa6JUkz63w",
:location_id => taxonomies(:location1).id,
:organization_id => taxonomies(:organization1).id
dc38aad3 Joseph Magen
}
end

e653ec5e Timo Goebel
def valid_compute_attrs
{
:compute_attributes => {
:cpus => 4,
:memory => 1024
}
}
end

cfd1c413 Tomas Strachota
def valid_attrs
net_attrs = {
:ip => '10.0.0.20',
:mac => '52:53:00:1e:85:93'
}
e653ec5e Timo Goebel
basic_attrs.merge(net_attrs).merge(valid_compute_attrs)
cfd1c413 Tomas Strachota
end

4cbf879e Lukas Zapletal
def valid_attrs_with_root(extra_attrs = {})
{ :host => valid_attrs.merge(extra_attrs) }
end

cfd1c413 Tomas Strachota
def basic_attrs_with_profile(compute_attrs)
basic_attrs.merge(
:compute_resource_id => compute_attrs.compute_resource_id,
:compute_profile_id => compute_attrs.compute_profile_id
)
end

8e81effc Amit Karsale
def basic_attrs_with_hg
hostgroup_attr = {
:hostgroup_id => Hostgroup.first.id
}
basic_attrs.merge(hostgroup_attr)
end

cfd1c413 Tomas Strachota
def nics_attrs
[{
:primary => true,
:ip => '10.0.0.20',
:mac => '00:11:22:33:44:00'
3cd8c84b Michael Moll
}, {
cfd1c413 Tomas Strachota
:type => 'bmc',
:provider => 'IPMI',
:mac => '00:11:22:33:44:01'
3cd8c84b Michael Moll
}, {
cfd1c413 Tomas Strachota
:mac => '00:11:22:33:44:02',
:_destroy => 1
}]
end

def expected_compute_attributes(compute_attrs, index)
compute_attrs.vm_interfaces[index].update("from_profile" => compute_attrs.compute_profile.name)
end

b299f9c9 Dominic Cleal
def expect_attribute_modifier(modifier_class, args)
modifier = mock(modifier_class.name)
modifier_class.expects(:new).with(*args).returns(modifier)
Host.any_instance.expects(:apply_compute_profile).with(modifier)
47990639 Tomas Strachota
end

dc38aad3 Joseph Magen
test "should get index" do
d041d4bb Dominic Cleal
get :index
dc38aad3 Joseph Magen
assert_response :success
assert_not_nil assigns(:hosts)
hosts = ActiveSupport::JSON.decode(@response.body)
assert !hosts.empty?
end

71c08300 Tomer Brisker
test "should get thin index" do
d041d4bb Dominic Cleal
get :index, params: { thin: true }
71c08300 Tomer Brisker
assert_response :success
assert_not_nil assigns(:hosts)
hosts = ActiveSupport::JSON.decode(@response.body)
assert !hosts.empty?
assert_equal Host.all.pluck(:id, :name), hosts['results'].map(&:values)
end

d5f2f1de Amir Fefer
test "subtotal should be the same as the search count with thin" do
FactoryBot.create_list(:host, 2)
Host.last.update_attribute(:name, 'test')

get :index, params: { thin: true, per_page: 1, search: 'host' }
assert_response :success
assert_not_nil assigns(:hosts)
hosts = ActiveSupport::JSON.decode(@response.body)
assert_equal hosts['subtotal'], Host.search_for('host').size
end

87f8f03e Shimon Shtein
test "should include registered scope on index" do
# remember the previous state
old_scopes = Api::V2::HostsController.scopes_for(:index).dup

scope_accessed = false
Api::V2::HostsController.add_scope_for(:index) do |base_scope|
scope_accessed = true
base_scope
end
d041d4bb Dominic Cleal
get :index
87f8f03e Shimon Shtein
assert_response :success
assert_not_nil assigns(:hosts)
hosts = ActiveSupport::JSON.decode(@response.body)
assert !hosts.empty?

68388bc2 Michael Moll
# restore the previous state
87f8f03e Shimon Shtein
new_scopes = Api::V2::HostsController.scopes_for(:index)
new_scopes.keep_if { |s| old_scopes.include?(s) }
end

7c5b8bd6 Shlomi Zadok
test "should get attributes in ordered index" do
last_record.update(ip: "127.13.0.1")
d041d4bb Dominic Cleal
get :index, params: { order: "mac" }
7c5b8bd6 Shlomi Zadok
assert_response :success
assert_not_nil assigns(:hosts)
hosts = ActiveSupport::JSON.decode(@response.body)
ip_addresses = hosts["results"].map { |host| host["ip"] }
refute ip_addresses.empty?
assert_includes(ip_addresses, "127.13.0.1")
end

b819a37b Trey Dockendorf
test "should get parameters from index" do
last_record.parameters = [HostParameter.new(name: 'foo', value: 'bar')]
d041d4bb Dominic Cleal
get :index, params: { include: ['parameters'] }
b819a37b Trey Dockendorf
assert_response :success
assert_not_nil assigns(:hosts)
hosts = ActiveSupport::JSON.decode(@response.body)
parameters = hosts['results'].map { |host| host['parameters'] }.flatten
parameter = parameters.select { |param| param['name'] == 'foo' }.first
refute parameters.empty?
assert_equal parameter['value'], 'bar'
end

test "should get all_parameters from index" do
8c6bc83e Marek Hulan
hostgroup = FactoryBot.create(:hostgroup, :with_parent, :with_domain, :with_os)
b819a37b Trey Dockendorf
hostgroup.group_parameters = [GroupParameter.new(name: 'foobar', value: 'baz')]
last_record.parameters = [HostParameter.new(name: 'foo', value: 'bar')]
last_record.update_attribute(:hostgroup_id, hostgroup.id)
d041d4bb Dominic Cleal
get :index, params: { include: ['all_parameters'] }
b819a37b Trey Dockendorf
assert_response :success
assert_not_nil assigns(:hosts)
hosts = ActiveSupport::JSON.decode(@response.body)
parameters = hosts['results'].map { |host| host['all_parameters'] }.flatten
parameter = parameters.select { |param| param['name'] == 'foo' }.first
inherited_parameter = parameters.select { |param| param['name'] == 'foobar' }.first
refute parameters.empty?
assert_equal parameter['value'], 'bar'
assert_equal inherited_parameter['value'], 'baz'
end

dc38aad3 Joseph Magen
test "should show individual record" do
d041d4bb Dominic Cleal
get :show, params: { :id => @host.to_param }
dc38aad3 Joseph Magen
assert_response :success
show_response = ActiveSupport::JSON.decode(@response.body)
assert !show_response.empty?
end

7c671609 Dominic Cleal
test 'should show host with model name' do
8c6bc83e Marek Hulan
model = FactoryBot.create(:model)
7c671609 Dominic Cleal
@host.update_attribute(:model_id, model.id)
d041d4bb Dominic Cleal
get :show, params: { :id => @host.to_param }
7c671609 Dominic Cleal
assert_response :success
show_response = ActiveSupport::JSON.decode(@response.body)
assert_equal model.id, show_response['model_id']
assert_equal model.name, show_response['model_name']
end

558a7590 Nagoor Shaik
test "should show host owner name" do
owner = User.first
8c6bc83e Marek Hulan
host = FactoryBot.create(:host, :owner => owner)
d041d4bb Dominic Cleal
get :show, params: {:id => host.id}, session: set_session_user
558a7590 Nagoor Shaik
assert_response :success
response = ActiveSupport::JSON.decode(@response.body)
assert_equal owner.name, response["owner_name"]
end

dc38aad3 Joseph Magen
test "should create host" do
disable_orchestration
assert_difference('Host.count') do
d041d4bb Dominic Cleal
post :create, params: { :host => valid_attrs }
dc38aad3 Joseph Magen
end
d575926a alongoldboim
assert_response :created
dc38aad3 Joseph Magen
end

7ee381e9 Lukas Zapletal
test "should create host with host_parameters_attributes" do
disable_orchestration
d0732ecf Dominic Cleal
Foreman::Deprecation.expects(:api_deprecation_warning).with('Field host_parameters_attributes.nested ignored')
a9a584ee odovzhenko
attrs = [{"name" => "compute_resource_id", "value" => "1", "nested" => "true"}]
7ee381e9 Lukas Zapletal
assert_difference('Host.count') do
d041d4bb Dominic Cleal
post :create, params: { :host => valid_attrs.merge(:host_parameters_attributes => attrs) }
7ee381e9 Lukas Zapletal
end
assert_response :created
a9a584ee odovzhenko
assert_equal JSON.parse(@response.body)['parameters'][0]['name'], attrs[0]['name'], "Can't create host with valid parameters #{attrs}"
assert_equal JSON.parse(@response.body)['parameters'][0]['value'], attrs[0]['value'], "Can't create host with valid parameters #{attrs}"
7ee381e9 Lukas Zapletal
end

test "should create host with host_parameters_attributes sent in a hash" do
disable_orchestration
d0732ecf Dominic Cleal
Foreman::Deprecation.expects(:api_deprecation_warning).with('Field host_parameters_attributes.nested ignored')
7ee381e9 Lukas Zapletal
assert_difference('Host.count') do
attrs = {"0" => {"name" => "compute_resource_id", "value" => "1", "nested" => "true"}}
d041d4bb Dominic Cleal
post :create, params: { :host => valid_attrs.merge(:host_parameters_attributes => attrs) }
7ee381e9 Lukas Zapletal
end
assert_response :created
end

cfd1c413 Tomas Strachota
test "should create interfaces" do
disable_orchestration

d041d4bb Dominic Cleal
post :create, params: { :host => basic_attrs.merge!(:interfaces_attributes => nics_attrs) }
d575926a alongoldboim
assert_response :created
4cbf879e Lukas Zapletal
assert_equal 2, last_record.interfaces.count
cfd1c413 Tomas Strachota
4cbf879e Lukas Zapletal
assert last_record.interfaces.find_by_mac('00:11:22:33:44:00').primary?
assert_equal Nic::Managed, last_record.interfaces.find_by_mac('00:11:22:33:44:00').class
assert_equal Nic::BMC, last_record.interfaces.find_by_mac('00:11:22:33:44:01').class
cfd1c413 Tomas Strachota
end

test "should create interfaces sent in a hash" do
disable_orchestration
hash_nics_attrs = nics_attrs.inject({}) do |hash, item|
12612809 Dominic Cleal
hash.update((hash.count + 1).to_s => item)
cfd1c413 Tomas Strachota
end

d041d4bb Dominic Cleal
post :create, params: { :host => basic_attrs.merge!(:interfaces_attributes => hash_nics_attrs) }
d575926a alongoldboim
assert_response :created
4cbf879e Lukas Zapletal
assert_equal 2, last_record.interfaces.count
cfd1c413 Tomas Strachota
4cbf879e Lukas Zapletal
assert last_record.interfaces.find_by_mac('00:11:22:33:44:00').primary?
assert_equal Nic::Managed, last_record.interfaces.find_by_mac('00:11:22:33:44:00').class
assert_equal Nic::BMC, last_record.interfaces.find_by_mac('00:11:22:33:44:01').class
cfd1c413 Tomas Strachota
end

test "should fail with unknown interface type" do
disable_orchestration

attrs = basic_attrs.merge!(:interfaces_attributes => nics_attrs)
attrs[:interfaces_attributes][0][:type] = "unknown"

d041d4bb Dominic Cleal
post :create, params: { :host => attrs }
cfd1c413 Tomas Strachota
assert_response :unprocessable_entity
assert_match /Unknown interface type/, JSON.parse(response.body)['error']['message']
end

test "should create interfaces from compute profile" do
disable_orchestration

compute_attrs = compute_attributes(:with_interfaces)
e653ec5e Timo Goebel
post :create, params: { :host => basic_attrs_with_profile(compute_attrs).merge(:interfaces_attributes => nics_attrs) }
d575926a alongoldboim
assert_response :created
cfd1c413 Tomas Strachota
5f606e11 Daniel Lobato Garcia
as_admin do
assert_equal compute_attrs.vm_interfaces.count,
last_record.interfaces.count
assert_equal expected_compute_attributes(compute_attrs, 0),
last_record.interfaces.find_by_mac('00:11:22:33:44:00').compute_attributes
assert_equal expected_compute_attributes(compute_attrs, 1),
last_record.interfaces.find_by_mac('00:11:22:33:44:01').compute_attributes
end
cfd1c413 Tomas Strachota
end

dc38aad3 Joseph Magen
test "should create host with managed is false if parameter is passed" do
disable_orchestration
d041d4bb Dominic Cleal
post :create, params: { :host => valid_attrs.merge!(:managed => false) }
d575926a alongoldboim
assert_response :created
4cbf879e Lukas Zapletal
assert_equal false, last_record.managed?
dc38aad3 Joseph Magen
end

47990639 Tomas Strachota
test "create applies attribute modifiers on the new host" do
disable_orchestration
b299f9c9 Dominic Cleal
expect_attribute_modifier(ComputeAttributeMerge, [])
expect_attribute_modifier(InterfaceMerge, [{:merge_compute_attributes => true}])
d041d4bb Dominic Cleal
post :create, params: { :host => valid_attrs }
47990639 Tomas Strachota
end

test "update applies attribute modifiers on the host" do
disable_orchestration
b299f9c9 Dominic Cleal
expect_attribute_modifier(ComputeAttributeMerge, [])
expect_attribute_modifier(InterfaceMerge, [{:merge_compute_attributes => true}])
d041d4bb Dominic Cleal
put :update, params: { :id => @host.to_param, :host => valid_attrs }
47990639 Tomas Strachota
end

e653ec5e Timo Goebel
test "update applies attribute modifiers on the host when compute profile is changed" do
disable_orchestration
expect_attribute_modifier(ComputeAttributeMerge, [])
expect_attribute_modifier(InterfaceMerge, [{:merge_compute_attributes => true}])

compute_attrs = compute_attributes(:with_interfaces)
put :update, params: { :id => @host.to_param, :host => basic_attrs_with_profile(compute_attrs) }
end

dc38aad3 Joseph Magen
test "should update host" do
d041d4bb Dominic Cleal
put :update, params: { :id => @host.to_param, :host => valid_attrs }
dc38aad3 Joseph Magen
assert_response :success
end

8e81effc Amit Karsale
test "should update hostgroup_id of host" do
5cbba9ec Tomer Brisker
host = FactoryBot.create(:host, basic_attrs_with_hg)
hg = FactoryBot.create(:hostgroup, :with_environment)
put :update, params: { :id => host.to_param, :host => { :hostgroup_id => hg.id }}
8e81effc Amit Karsale
assert_response :success
5cbba9ec Tomer Brisker
host.reload
assert_equal host.hostgroup_id, hg.id
8e81effc Amit Karsale
end

e653ec5e Timo Goebel
test 'does not set compute profile when updating arbitrary field' do
Host.any_instance.expects(:apply_compute_profile).never
put :update, params: { :id => @host.to_param, :host => { :comment => 'This is a comment' } }
end

9a41f58f Tomas Strachota
test "updating interface type isn't allowed" do
8c6bc83e Marek Hulan
@host = FactoryBot.create(:host, :interfaces => [FactoryBot.build(:nic_bond, :primary => true)])
9a41f58f Tomas Strachota
nic_id = @host.interfaces.first.id
d041d4bb Dominic Cleal
put :update, params: { :id => @host.to_param, :host => { :interfaces_attributes => [{ :id => nic_id, :name => 'newname', :type => 'bmc'}] } }
9a41f58f Tomas Strachota
assert_response :unprocessable_entity
body = ActiveSupport::JSON.decode(response.body)
assert_includes body['error']['errors'].keys, 'interfaces.type'
end

test "should update interfaces without changing their type" do
8c6bc83e Marek Hulan
@host = FactoryBot.create(:host, :interfaces => [FactoryBot.build(:nic_bond, :primary => true)])
9a41f58f Tomas Strachota
nic_id = @host.interfaces.first.id
d041d4bb Dominic Cleal
put :update, params: { :id => @host.to_param, :host => { :interfaces_attributes => [{ :id => nic_id, :name => 'newname' }] } }
9a41f58f Tomas Strachota
assert_response :success
assert_equal('Nic::Bond', Nic::Base.find(nic_id).type)
assert_equal('newname', Nic::Base.find(nic_id).name)
end

cfd1c413 Tomas Strachota
test "should update interfaces from compute profile" do
disable_orchestration

compute_attrs = compute_attributes(:with_interfaces)

d041d4bb Dominic Cleal
put :update, params: { :id => @host.to_param, :host => basic_attrs_with_profile(compute_attrs) }
cfd1c413 Tomas Strachota
assert_response :success

5f606e11 Daniel Lobato Garcia
as_admin do
@host.interfaces.reload
assert_equal compute_attrs.vm_interfaces.count, @host.interfaces.count
assert_equal expected_compute_attributes(compute_attrs, 0), @host.interfaces.find_by_primary(true).compute_attributes
assert_equal expected_compute_attributes(compute_attrs, 1), @host.interfaces.find_by_primary(false).compute_attributes
end
cfd1c413 Tomas Strachota
end

a2610e98 Joseph Magen
test "should update host without :host root node and rails wraps it correctly" do
d041d4bb Dominic Cleal
put :update, params: { :id => @host.to_param, :name => 'newhostname' }
a2610e98 Joseph Magen
request_parameters = @request.env['action_dispatch.request.request_parameters']
assert request_parameters[:host]
assert_equal 'newhostname', request_parameters[:host][:name]
assert_response :success
end

dc38aad3 Joseph Magen
test "should destroy hosts" do
assert_difference('Host.count', -1) do
d041d4bb Dominic Cleal
delete :destroy, params: { :id => @host.to_param }
dc38aad3 Joseph Magen
end
assert_response :success
end

test "should show status hosts" do
d0732ecf Dominic Cleal
Foreman::Deprecation.expects(:api_deprecation_warning).with(regexp_matches(%r{/status route is deprecated}))
d041d4bb Dominic Cleal
get :status, params: { :id => @host.to_param }
dc38aad3 Joseph Magen
assert_response :success
end

e54016da Marek Hulan
test "should show specific status hosts" do
d041d4bb Dominic Cleal
get :get_status, params: { :id => @host.to_param, :type => 'global' }
e54016da Marek Hulan
assert_response :success
end

dc38aad3 Joseph Magen
test "should be able to create hosts even when restricted" do
disable_orchestration
assert_difference('Host.count') do
d041d4bb Dominic Cleal
post :create, params: { :host => valid_attrs }
dc38aad3 Joseph Magen
end
assert_response :success
end

test "should allow access to restricted user who owns the host" do
8c6bc83e Marek Hulan
host = FactoryBot.create(:host, :owner => users(:scoped), :organization => taxonomies(:organization1), :location => taxonomies(:location1))
a4d7a037 Marek Hulan
setup_user 'view', 'hosts', "owner_type = User and owner_id = #{users(:scoped).id}", :scoped
d041d4bb Dominic Cleal
get :show, params: { :id => host.to_param }
dc38aad3 Joseph Magen
assert_response :success
end

test "should allow to update for restricted user who owns the host" do
disable_orchestration
8c6bc83e Marek Hulan
host = FactoryBot.create(:host, :owner => users(:scoped), :organization => taxonomies(:organization1), :location => taxonomies(:location1))
a4d7a037 Marek Hulan
setup_user 'edit', 'hosts', "owner_type = User and owner_id = #{users(:scoped).id}", :scoped
d041d4bb Dominic Cleal
put :update, params: { :id => host.to_param, :host => valid_attrs }
dc38aad3 Joseph Magen
assert_response :success
end

test "should allow destroy for restricted user who owns the hosts" do
8c6bc83e Marek Hulan
host = FactoryBot.create(:host, :owner => users(:scoped), :organization => taxonomies(:organization1), :location => taxonomies(:location1))
dc38aad3 Joseph Magen
assert_difference('Host.count', -1) do
a4d7a037 Marek Hulan
setup_user 'destroy', 'hosts', "owner_type = User and owner_id = #{users(:scoped).id}", :scoped
d041d4bb Dominic Cleal
delete :destroy, params: { :id => host.to_param }
dc38aad3 Joseph Magen
end
assert_response :success
end

test "should allow show status for restricted user who owns the hosts" do
d0732ecf Dominic Cleal
Foreman::Deprecation.expects(:api_deprecation_warning).with(regexp_matches(%r{/status route is deprecated}))
8c6bc83e Marek Hulan
host = FactoryBot.create(:host, :owner => users(:scoped), :organization => taxonomies(:organization1), :location => taxonomies(:location1))
a4d7a037 Marek Hulan
setup_user 'view', 'hosts', "owner_type = User and owner_id = #{users(:scoped).id}", :scoped
d041d4bb Dominic Cleal
get :status, params: { :id => host.to_param }
dc38aad3 Joseph Magen
assert_response :success
end

test "should not allow access to a host out of users hosts scope" do
acfbc458 Marek Hulan
setup_user 'view', 'hosts', "owner_type = User and owner_id = #{users(:restricted).id}", :restricted
d041d4bb Dominic Cleal
get :show, params: { :id => @host.to_param }
dc38aad3 Joseph Magen
assert_response :not_found
end

test "should not list a host out of users hosts scope" do
8c6bc83e Marek Hulan
host = FactoryBot.create(:host, :owner => users(:scoped), :organization => taxonomies(:organization1), :location => taxonomies(:location1))
a4d7a037 Marek Hulan
setup_user 'view', 'hosts', "owner_type = User and owner_id = #{users(:scoped).id}", :scoped
d041d4bb Dominic Cleal
get :index
dc38aad3 Joseph Magen
assert_response :success
hosts = ActiveSupport::JSON.decode(@response.body)
cc739ab4 Joseph Mitchell Magen
ids = hosts['results'].map { |hash| hash['id'] }
e14b5758 Greg Sutcliffe
refute_includes ids, @host.id
assert_includes ids, host.id
dc38aad3 Joseph Magen
end

test "should not update host out of users hosts scope" do
acfbc458 Marek Hulan
setup_user 'edit', 'hosts', "owner_type = User and owner_id = #{users(:restricted).id}", :restricted
d041d4bb Dominic Cleal
put :update, params: { :id => @host.to_param }
dc38aad3 Joseph Magen
assert_response :not_found
end

test "should not delete hosts out of users hosts scope" do
acfbc458 Marek Hulan
setup_user 'destroy', 'hosts', "owner_type = User and owner_id = #{users(:restricted).id}", :restricted
d041d4bb Dominic Cleal
delete :destroy, params: { :id => @host.to_param }
dc38aad3 Joseph Magen
assert_response :not_found
end

test "should not show status of hosts out of users hosts scope" do
acfbc458 Marek Hulan
setup_user 'view', 'hosts', "owner_type = User and owner_id = #{users(:restricted).id}", :restricted
d041d4bb Dominic Cleal
get :status, params: { :id => @host.to_param }
dc38aad3 Joseph Magen
assert_response :not_found
end

7e8bfe82 Walter Huf
test "should show hosts vm attributes" do
8c6bc83e Marek Hulan
host = FactoryBot.create(:host, :compute_resource => compute_resources(:one))
f4459c11 David Davis
ComputeResource.any_instance.stubs(:vm_compute_attributes_for).returns(:cpus => 4)
d041d4bb Dominic Cleal
get :vm_compute_attributes, params: { :id => host.to_param }
7e8bfe82 Walter Huf
assert_response :success
data = JSON.parse(@response.body)
4269abbd Tomas Strachota
assert_equal data, "cpus" => 4, "memory" => nil
7e8bfe82 Walter Huf
ComputeResource.any_instance.unstub(:vm_compute_attributes_for)
end

5f029ed6 Daniel Lobato
def set_remote_user_to(user)
dc38aad3 Joseph Magen
@request.env['REMOTE_USER'] = user.login
end

test "when REMOTE_USER is provided and both authorize_login_delegation{,_api}
are set, authentication should succeed w/o valid session cookies" do
Setting[:authorize_login_delegation] = true
Setting[:authorize_login_delegation_api] = true
set_remote_user_to users(:admin)
User.current = nil # User.current is admin at this point (from initialize_host)
host = Host.first
d041d4bb Dominic Cleal
get :show, params: { :id => host.to_param, :format => 'json' }
dc38aad3 Joseph Magen
assert_response :success
d041d4bb Dominic Cleal
get :show, params: { :id => host.to_param }
dc38aad3 Joseph Magen
assert_response :success
end

3ccd0ef6 Jason Montleon
test "should disassociate host" do
8c6bc83e Marek Hulan
host = FactoryBot.create(:host, :on_compute_resource)
3ccd0ef6 Jason Montleon
assert host.compute?
d041d4bb Dominic Cleal
put :disassociate, params: { :id => host.to_param }
3ccd0ef6 Jason Montleon
assert_response :success
refute host.reload.compute?
end

01055e77 Greg Sutcliffe
def fact_json
ea98080f Dominic Cleal
@json ||= read_json_fixture('facts/brslc022.facts.json')
01055e77 Greg Sutcliffe
end

2fba6ad7 Ondrej Prazak
def test_rebuild_config_optimistic
Host.any_instance.expects(:recreate_config).returns({ "TFTP" => true, "DNS" => true, "DHCP" => true })
8c6bc83e Marek Hulan
host = FactoryBot.create(:host)
d041d4bb Dominic Cleal
post :rebuild_config, params: { :id => host.to_param }, session: set_session_user
2fba6ad7 Ondrej Prazak
assert_response :success
end

def test_rebuild_config_pessimistic
Host.any_instance.expects(:recreate_config).returns({ "TFTP" => false, "DNS" => false, "DHCP" => false })
8c6bc83e Marek Hulan
host = FactoryBot.create(:host)
d041d4bb Dominic Cleal
post :rebuild_config, params: { :id => host.to_param }, session: set_session_user
2fba6ad7 Ondrej Prazak
assert_response 422
end

ff5900e9 Trey Dockendorf
def test_rebuild_tftp_config
Host.any_instance.expects(:recreate_config).returns({ "TFTP" => true })
8c6bc83e Marek Hulan
host = FactoryBot.create(:host)
d041d4bb Dominic Cleal
post :rebuild_config, params: { :id => host.to_param, :only => ['TFTP'] }, session: set_session_user
ff5900e9 Trey Dockendorf
assert_response :success
end

01055e77 Greg Sutcliffe
def test_create_valid_node_from_json_facts_object_without_certname
9d43fc71 Michael Moll
User.current = nil
01055e77 Greg Sutcliffe
hostname = fact_json['name']
facts = fact_json['facts']
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts }, session: set_session_user
01055e77 Greg Sutcliffe
assert_response :success
end

def test_create_valid_node_from_json_facts_object_with_certname
9d43fc71 Michael Moll
User.current = nil
01055e77 Greg Sutcliffe
hostname = fact_json['name']
certname = fact_json['certname']
facts = fact_json['facts']
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :certname => certname, :facts => facts }, session: set_session_user
01055e77 Greg Sutcliffe
assert_response :success
end

def test_create_invalid
9d43fc71 Michael Moll
User.current = nil
01055e77 Greg Sutcliffe
hostname = fact_json['name']
facts = fact_json['facts'].except('operatingsystem')
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts }, session: set_session_user
01055e77 Greg Sutcliffe
assert_response :unprocessable_entity
end

9883149a amirfefer
test 'set hostgroup when foreman_hostgroup present in facts' do
Setting[:create_new_host_when_facts_are_uploaded] = true
8c6bc83e Marek Hulan
hostgroup = FactoryBot.create(:hostgroup)
9883149a amirfefer
hostname = fact_json['name']
facts = fact_json['facts']
facts['foreman_hostgroup'] = hostgroup.title
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts }
9883149a amirfefer
assert_response :success
5f606e11 Daniel Lobato Garcia
assert_equal hostgroup.id, Host.find_by(:name => hostname).hostgroup_id
9883149a amirfefer
end

test 'assign hostgroup attributes when foreman_hostgroup present in facts' do
Setting[:create_new_host_when_facts_are_uploaded] = true
8c6bc83e Marek Hulan
hostgroup = FactoryBot.create(:hostgroup, :with_rootpass)
9883149a amirfefer
hostname = fact_json['name']
facts = fact_json['facts']
facts['foreman_hostgroup'] = hostgroup.title
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts }
9883149a amirfefer
assert_response :success
assert_equal hostgroup.root_pass, Host.find_by(:name => hostname).root_pass
end

c3b33536 Stephen Benjamin
test 'when ":restrict_registered_smart_proxies" is false, HTTP requests should be able to import facts' do
68388bc2 Michael Moll
User.current = users(:one) # use an unprivileged user, not apiadmin
c3b33536 Stephen Benjamin
Setting[:restrict_registered_smart_proxies] = false
01055e77 Greg Sutcliffe
SETTINGS[:require_ssl] = false

Resolv.any_instance.stubs(:getnames).returns(['else.where'])
hostname = fact_json['name']
facts = fact_json['facts']
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts }
5ab79857 Ohad Levy
assert_nil @controller.detected_proxy
01055e77 Greg Sutcliffe
assert_response :success
end

test 'hosts with a registered smart proxy on should import facts successfully' do
b1ac29e9 Lukas Zapletal
ProxyAPI::Features.any_instance.stubs(:features => Feature.name_map.keys)
8dcc90be Marek Hulán
proxy = smart_proxies(:puppetmaster)
proxy.update_attribute(:url, 'https://factsimporter.foreman')

68388bc2 Michael Moll
User.current = users(:one) # use an unprivileged user, not apiadmin
c3b33536 Stephen Benjamin
Setting[:restrict_registered_smart_proxies] = true
Setting[:require_ssl_smart_proxies] = false
01055e77 Greg Sutcliffe
f4459c11 David Davis
host = URI.parse(proxy.url).host
5ab79857 Ohad Levy
Resolv.any_instance.stubs(:getnames).returns([host])
01055e77 Greg Sutcliffe
hostname = fact_json['name']
facts = fact_json['facts']
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts }
5ab79857 Ohad Levy
assert_equal proxy, @controller.detected_proxy
01055e77 Greg Sutcliffe
assert_response :success
end

test 'hosts without a registered smart proxy on should not be able to import facts' do
68388bc2 Michael Moll
User.current = users(:one) # use an unprivileged user, not apiadmin
c3b33536 Stephen Benjamin
Setting[:restrict_registered_smart_proxies] = true
Setting[:require_ssl_smart_proxies] = false
01055e77 Greg Sutcliffe
Resolv.any_instance.stubs(:getnames).returns(['another.host'])
hostname = fact_json['name']
facts = fact_json['facts']
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts }
01055e77 Greg Sutcliffe
assert_response :forbidden
end

test 'hosts with a registered smart proxy and SSL cert should import facts successfully' do
68388bc2 Michael Moll
User.current = users(:one) # use an unprivileged user, not apiadmin
c3b33536 Stephen Benjamin
Setting[:restrict_registered_smart_proxies] = true
Setting[:require_ssl_smart_proxies] = true
01055e77 Greg Sutcliffe
@request.env['HTTPS'] = 'on'
@request.env['SSL_CLIENT_S_DN'] = 'CN=else.where'
@request.env['SSL_CLIENT_VERIFY'] = 'SUCCESS'
hostname = fact_json['name']
facts = fact_json['facts']
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts }
01055e77 Greg Sutcliffe
assert_response :success
end

test 'hosts without a registered smart proxy but with an SSL cert should not be able to import facts' do
68388bc2 Michael Moll
User.current = users(:one) # use an unprivileged user, not apiadmin
c3b33536 Stephen Benjamin
Setting[:restrict_registered_smart_proxies] = true
Setting[:require_ssl_smart_proxies] = true
01055e77 Greg Sutcliffe
@request.env['HTTPS'] = 'on'
@request.env['SSL_CLIENT_S_DN'] = 'CN=another.host'
@request.env['SSL_CLIENT_VERIFY'] = 'SUCCESS'
hostname = fact_json['name']
facts = fact_json['facts']
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts }
01055e77 Greg Sutcliffe
assert_response :forbidden
end

test 'hosts with an unverified SSL cert should not be able to import facts' do
68388bc2 Michael Moll
User.current = users(:one) # use an unprivileged user, not apiadmin
c3b33536 Stephen Benjamin
Setting[:restrict_registered_smart_proxies] = true
Setting[:require_ssl_smart_proxies] = true
01055e77 Greg Sutcliffe
@request.env['HTTPS'] = 'on'
@request.env['SSL_CLIENT_S_DN'] = 'CN=secure.host'
@request.env['SSL_CLIENT_VERIFY'] = 'FAILED'
hostname = fact_json['name']
facts = fact_json['facts']
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts }
01055e77 Greg Sutcliffe
assert_response :forbidden
end

c3b33536 Stephen Benjamin
test 'when "require_ssl_smart_proxies" and "require_ssl" are true, HTTP requests should not be able to import facts' do
68388bc2 Michael Moll
User.current = users(:one) # use an unprivileged user, not apiadmin
c3b33536 Stephen Benjamin
Setting[:restrict_registered_smart_proxies] = true
Setting[:require_ssl_smart_proxies] = true
01055e77 Greg Sutcliffe
SETTINGS[:require_ssl] = true

Resolv.any_instance.stubs(:getnames).returns(['else.where'])
hostname = fact_json['name']
facts = fact_json['facts']
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts }
01055e77 Greg Sutcliffe
assert_response :forbidden
end

c3b33536 Stephen Benjamin
test 'when "require_ssl_smart_proxies" is true and "require_ssl" is false, HTTP requests should be able to import facts' do
68388bc2 Michael Moll
User.current = users(:one) # use an unprivileged user, not apiadmin
c3b33536 Stephen Benjamin
# since require_ssl_smart_proxies is only applicable to HTTPS connections, both should be set
Setting[:restrict_registered_smart_proxies] = true
Setting[:require_ssl_smart_proxies] = true
01055e77 Greg Sutcliffe
SETTINGS[:require_ssl] = false

Resolv.any_instance.stubs(:getnames).returns(['else.where'])
hostname = fact_json['name']
facts = fact_json['facts']
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts }
01055e77 Greg Sutcliffe
assert_response :success
end

test "when a bad :type is requested, :unprocessable_entity is returned" do
9d43fc71 Michael Moll
User.current = nil
01055e77 Greg Sutcliffe
hostname = fact_json['name']
facts = fact_json['facts']
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts, :type => "Host::Invalid" }, session: set_session_user
01055e77 Greg Sutcliffe
assert_response :unprocessable_entity
2656873b Martin Bačovský
assert JSON.parse(response.body)['message'] =~ /ERF42-3624/
01055e77 Greg Sutcliffe
end

test "when the imported host failed to save, :unprocessable_entity is returned" do
Host::Managed.any_instance.stubs(:save).returns(false)
43c4bd72 Marek Hulan
Nic::Managed.any_instance.stubs(:save).returns(false)
01055e77 Greg Sutcliffe
errors = ActiveModel::Errors.new(Host::Managed.new)
errors.add :foo, 'A stub failure'
Host::Managed.any_instance.stubs(:errors).returns(errors)
9d43fc71 Michael Moll
User.current = nil
01055e77 Greg Sutcliffe
hostname = fact_json['name']
facts = fact_json['facts']
d041d4bb Dominic Cleal
post :facts, params: { :name => hostname, :facts => facts }, session: set_session_user
01055e77 Greg Sutcliffe
assert_response :unprocessable_entity
0f7d219a Daniel Lobato
assert_equal 'A stub failure', JSON.parse(response.body)['error']['errors']['foo'].first
01055e77 Greg Sutcliffe
end

e02a2ff2 Julien Pivotto
test 'non-admin user with power_host permission can boot a vm' do
8c6bc83e Marek Hulan
@bmchost = FactoryBot.create(:host, :managed)
FactoryBot.create(:nic_bmc, :host => @bmchost)
e02a2ff2 Julien Pivotto
ProxyAPI::BMC.any_instance.stubs(:power).with(:action => 'status').returns("on")
8c6bc83e Marek Hulan
role = FactoryBot.create(:role, :name => 'power_hosts')
e02a2ff2 Julien Pivotto
role.add_permissions!(['power_hosts'])
8c6bc83e Marek Hulan
api_user = FactoryBot.create(:user)
e02a2ff2 Julien Pivotto
api_user.update_attribute :roles, [role]
as_user(api_user) do
d041d4bb Dominic Cleal
put :power, params: { :id => @bmchost.to_param, :power_action => 'status' }
e02a2ff2 Julien Pivotto
end
assert_response :success
assert @response.body =~ /on/
end

8588f9ac Daniel Lobato
context 'BMC proxy operations' do
setup :initialize_proxy_ops

def initialize_proxy_ops
User.current = users(:apiadmin)
8c6bc83e Marek Hulan
@bmchost = FactoryBot.create(:host, :managed)
FactoryBot.create(:nic_bmc, :host => @bmchost)
8588f9ac Daniel Lobato
end

test "power call to interface" do
ProxyAPI::BMC.any_instance.stubs(:power).with(:action => 'status').returns("on")
d041d4bb Dominic Cleal
put :power, params: { :id => @bmchost.to_param, :power_action => 'status' }
8588f9ac Daniel Lobato
assert_response :success
assert @response.body =~ /on/
end

test "wrong power call fails gracefully" do
d041d4bb Dominic Cleal
put :power, params: { :id => @bmchost.to_param, :power_action => 'wrongmethod' }
8588f9ac Daniel Lobato
assert_response 422
2656873b Martin Bačovský
assert @response.body =~ /available methods are/
8588f9ac Daniel Lobato
end

test "boot call to interface" do
ProxyAPI::BMC.any_instance.stubs(:boot).with(:function => 'bootdevice', :device => 'bios').
f4459c11 David Davis
returns({ "action" => "bios", "result" => true } .to_json)
d041d4bb Dominic Cleal
put :boot, params: { :id => @bmchost.to_param, :device => 'bios' }
8588f9ac Daniel Lobato
assert_response :success
assert @response.body =~ /true/
end

test "wrong boot call to interface fails gracefully" do
d041d4bb Dominic Cleal
put :boot, params: { :id => @bmchost.to_param, :device => 'wrongbootdevice' }
8588f9ac Daniel Lobato
assert_response 422
2656873b Martin Bačovský
assert @response.body =~ /available devices are/
8588f9ac Daniel Lobato
end

4090ccb5 Daniel Lobato Garcia
context 'permissions' do
setup do
setup_user 'view', 'hosts'
setup_user 'ipmi_boot', 'hosts'
end

test 'returns error for non-admin user if BMC is not available' do
d041d4bb Dominic Cleal
put :boot, params: { :id => @host.to_param, :device => 'bios' },
session: set_session_user.merge(:user => @one.id)
4090ccb5 Daniel Lobato Garcia
assert_match(/No BMC NIC available/, response.body)
assert_response :unprocessable_entity
end

test 'responds correctly for non-admin user if BMC is available' do
ProxyAPI::BMC.any_instance.stubs(:boot).
with(:function => 'bootdevice', :device => 'bios').
returns({ "action" => "bios", "result" => true } .to_json)
d041d4bb Dominic Cleal
put :boot, params: { :id => @bmchost.to_param, :device => 'bios' },
session: set_session_user.merge(:user => @one.id)
4090ccb5 Daniel Lobato Garcia
assert_response :success
end
end

6f943886 Joseph Magen
test "should return correct total and subtotal metadata if search param is passed" do
8c6bc83e Marek Hulan
FactoryBot.create_list(:host, 8)
d041d4bb Dominic Cleal
get :index, params: { :search => @bmchost.name }
6f943886 Joseph Magen
assert_response :success
response = ActiveSupport::JSON.decode(@response.body)
a9a584ee odovzhenko
assert_equal response['search'], @bmchost.name
e14b5758 Greg Sutcliffe
assert_equal 10, response['total'] # one from setup, one from bmc setup, 8 here
f4459c11 David Davis
assert_equal 1, response['subtotal']
e14b5758 Greg Sutcliffe
assert_equal @bmchost.name, response['search']
6f943886 Joseph Magen
end
8588f9ac Daniel Lobato
end
8a817cb2 Shlomi Zadok
test 'template should return rendered template' do
8c6bc83e Marek Hulan
managed_host = FactoryBot.create(:host, :managed)
Host::Managed.any_instance.stubs(:provisioning_template).with({:kind => 'provision'}).returns(FactoryBot.create(:provisioning_template))
d041d4bb Dominic Cleal
get :template, params: { :id => managed_host.to_param, :kind => 'provision' }
8a817cb2 Shlomi Zadok
assert_response :success
assert @response.body =~ /template content/
end

test 'wrong template name should return not found' do
8c6bc83e Marek Hulan
managed_host = FactoryBot.create(:host, :managed)
8a817cb2 Shlomi Zadok
Host::Managed.any_instance.stubs(:provisioning_template).with({:kind => 'provitamin'}).returns(nil)
d041d4bb Dominic Cleal
get :template, params: { :id => managed_host.to_param, :kind => 'provitamin' }
8a817cb2 Shlomi Zadok
assert_response :not_found
end
a322a96e Ori Rabin
context 'search by hostgroup' do
def setup
8c6bc83e Marek Hulan
@hostgroup = FactoryBot.create(:hostgroup, :with_parent, :with_domain, :with_os)
@managed_host = FactoryBot.create(:host, :managed, :hostgroup => @hostgroup)
a322a96e Ori Rabin
end

test "should search host by hostgroup name" do
d041d4bb Dominic Cleal
get :index, params: { :search => "hostgroup_name = #{@hostgroup.name}" }
a322a96e Ori Rabin
assert_equal [@managed_host], assigns(:hosts)
end

test "should search host by hostgroup title" do
d041d4bb Dominic Cleal
get :index, params: { :search => "hostgroup_title = #{@hostgroup.title}" }
a322a96e Ori Rabin
assert_equal [@managed_host], assigns(:hosts)
end
end
94265cf7 Ori Rabin
f4d64312 kgaikwad
context 'host list after passing hostgroup filter' do
def setup
@hg1 = FactoryBot.create(:hostgroup, :with_parent, :with_domain, :with_os)
@unassigned_hg2 = FactoryBot.create(:hostgroup, :with_parent, :with_domain, :with_os)
@managed_host = FactoryBot.create(:host, :managed, :hostgroup => @hg1)
end

test "should return empty host list by unassigned hostgroup id" do
d041d4bb Dominic Cleal
get :index, params: { :hostgroup_id => @unassigned_hg2.id }
f4d64312 kgaikwad
assert_equal [], assigns(:hosts)
end

test "should return a host in list" do
d041d4bb Dominic Cleal
get :index, params: { :hostgroup_id => @hg1.id }
f4d64312 kgaikwad
assert_equal [@managed_host], assigns(:hosts)
end
end

94265cf7 Ori Rabin
test "user without view_params permission can't see host parameters" do
8c6bc83e Marek Hulan
host_with_parameter = FactoryBot.create(:host, :with_parameter)
8dcc90be Marek Hulán
setup_user "view", "hosts"
d041d4bb Dominic Cleal
get :show, params: { :id => host_with_parameter.to_param, :format => 'json' }
94265cf7 Ori Rabin
assert_empty JSON.parse(response.body)['parameters']
end

test "user with view_params permission can see host parameters" do
8c6bc83e Marek Hulan
host_with_parameter = FactoryBot.create(:host, :with_parameter)
94265cf7 Ori Rabin
setup_user "view", "hosts"
setup_user "view", "params"
d041d4bb Dominic Cleal
get :show, params: { :id => host_with_parameter.to_param, :format => 'json' }
94265cf7 Ori Rabin
assert_not_empty JSON.parse(response.body)['parameters']
end
a86dcf44 Klaas Demter
45e7f2c7 Ondřej Pražák
test "should get ENC values of host" do
8c6bc83e Marek Hulan
host = FactoryBot.create(:host, :with_puppetclass)
d041d4bb Dominic Cleal
get :enc, params: { :id => host.to_param }
45e7f2c7 Ondřej Pražák
assert_response :success
response = ActiveSupport::JSON.decode(@response.body)
puppet_class = response['data']['classes'].first rescue nil
assert_equal host.puppetclasses.first.name, puppet_class
end

38a9ed0c orrabin
context 'hidden parameters' do
test "should show a host parameter as hidden unless show_hidden_parameters is true" do
8c6bc83e Marek Hulan
host = FactoryBot.create(:host)
38a9ed0c orrabin
host.host_parameters.create!(:name => "foo", :value => "bar", :hidden_value => true)
d041d4bb Dominic Cleal
get :show, params: { :id => host.id }
38a9ed0c orrabin
show_response = ActiveSupport::JSON.decode(@response.body)
assert_equal '*****', show_response['parameters'].first['value']
end

test "should show a host parameter as unhidden when show_hidden_parameters is true" do
8c6bc83e Marek Hulan
host = FactoryBot.create(:host)
38a9ed0c orrabin
host.host_parameters.create!(:name => "foo", :value => "bar", :hidden_value => true)
d041d4bb Dominic Cleal
get :show, params: { :id => host.id, :show_hidden_parameters => 'true' }
38a9ed0c orrabin
show_response = ActiveSupport::JSON.decode(@response.body)
assert_equal 'bar', show_response['parameters'].first['value']
end
end

dd290225 Marek Hulan
test "should update existing host parameters using indexed hash format" do
8c6bc83e Marek Hulan
host = FactoryBot.create(:host, :with_parameter)
dd290225 Marek Hulan
host_param = host.parameters.first
d041d4bb Dominic Cleal
put :update, params: { :id => host.id, :host => { :host_parameters_attributes => { "0" => { :name => host_param.name, :value => "new_value" } } } }
dd290225 Marek Hulan
assert_response :success
end

test "should update existing host parameters using array format" do
8c6bc83e Marek Hulan
host = FactoryBot.create(:host, :with_parameter)
00ed8ba5 Ondřej Pražák
host_param = host.parameters.first
d041d4bb Dominic Cleal
put :update, params: { :id => host.id, :host => { :host_parameters_attributes => [{ :name => host_param.name, :value => "new_value" }] } }
00ed8ba5 Ondřej Pražák
assert_response :success
end

637da2f2 Timo Goebel
context 'import from compute resource' do
setup do
disable_orchestration
Fog.mock!
end
teardown { Fog.unmock! }

let(:domain) do
8c6bc83e Marek Hulan
FactoryBot.create(
637da2f2 Timo Goebel
:domain,
:name => 'virt.bos.redhat.com',
:location_ids => [ basic_attrs[:location_id] ],
:organization_ids => [ basic_attrs[:organization_id] ]
)
end
let(:compute_resource) do
8c6bc83e Marek Hulan
cr = FactoryBot.create(:compute_resource, :vmware, :uuid => 'Solutions')
637da2f2 Timo Goebel
ComputeResource.find_by_id(cr.id)
end
let(:uuid) { '5032c8a5-9c5e-ba7a-3804-832a03e16381' }
let(:import_attrs) { basic_attrs.except(:name, :domain_id, :compute_resource_id) }
let(:host_attrs) do
import_attrs.merge(
:compute_resource_id => compute_resource.id,
:uuid => uuid,
:ip => '10.0.0.20',
:build => true
)
end

test 'should create a host' do
assert domain
assert_difference('Host.count') do
d041d4bb Dominic Cleal
post :create, params: { :host => host_attrs }
637da2f2 Timo Goebel
end
assert_response :created
body = ActiveSupport::JSON.decode(@response.body)
assert_not_nil body['id']
edd5310f Dominic Cleal
as_admin do
host = Host.find_by_id(body['id'])
assert_equal 'dhcp75-197.virt.bos.redhat.com', host.name
assert_equal domain, host.domain
assert_equal '00:50:56:a9:00:28', host.mac
assert_equal true, host.build
end
637da2f2 Timo Goebel
end

test 'should not import if associated host exists' do
8c6bc83e Marek Hulan
FactoryBot.create(:host, :on_compute_resource, :uuid => uuid, :compute_resource => compute_resource)
d041d4bb Dominic Cleal
post :create, params: { :host => host_attrs }
637da2f2 Timo Goebel
assert_response :unprocessable_entity
body = ActiveSupport::JSON.decode(@response.body)
assert_includes body['error']['errors'].keys, 'uuid'
end
end

4cbf879e Lukas Zapletal
private

def last_record
Host.unscoped.order(:id).last
end

a86dcf44 Klaas Demter
test "host with two interfaces should get ips assigned on both interfaces" do
disable_orchestration
8c6bc83e Marek Hulan
subnet1 = FactoryBot.create(:subnet_ipv4, :name => 'my_subnet1', :network => '192.168.2.0', :from => '192.168.2.10',
a86dcf44 Klaas Demter
:to => '192.168.2.12', :dns_primary => '192.168.2.2', :gateway => '192.168.2.3',
:ipam => IPAM::MODES[:db], :location_ids => [ basic_attrs[:location_id] ],
:organization_ids => [ basic_attrs[:organization_id] ])
8c6bc83e Marek Hulan
subnet2 = FactoryBot.create(:subnet_ipv4, :name => 'my_subnet2', :network => '192.168.3.0', :from => '192.168.3.10',
a86dcf44 Klaas Demter
:to => '192.168.3.12', :dns_primary => '192.168.3.2', :gateway => '192.168.3.3',
:ipam => IPAM::MODES[:db], :location_ids => [ basic_attrs[:location_id] ],
:organization_ids => [ basic_attrs[:organization_id] ])
assert_difference('Host.count') do
d041d4bb Dominic Cleal
post :create, params: { :host => basic_attrs.merge!(:interfaces_attributes => [{ :primary => true, :mac => '00:11:22:33:44:00',
a86dcf44 Klaas Demter
:subnet_id => subnet1.id}, { :primary => false, :mac => '00:11:22:33:44:01', :subnet_id => subnet2.id}]) }
end
assert_response :created
4cbf879e Lukas Zapletal
assert_equal 2, last_record.interfaces.count
assert_equal '192.168.2.10', last_record.interfaces.find_by_mac('00:11:22:33:44:00').ip
assert_equal '192.168.3.10', last_record.interfaces.find_by_mac('00:11:22:33:44:01').ip
a86dcf44 Klaas Demter
end
a9a584ee odovzhenko
test "should not create host only with user owner type" do
assert_difference('Host.count', 0) do
post :create, params: { :host => valid_attrs.merge(:owner_type => 'User') }
end
assert_response :unprocessable_entity, "Can create host only with user owner type and without specifying owner"
end

test "should not create host only with usergroup owner type" do
assert_difference('Host.count', 0) do
post :create, params: { :host => valid_attrs.merge(:owner_type => 'Usergroup') }
end
assert_response :unprocessable_entity, "Can create host only with usergroup owner type and without specifying owner"
end

test "should not update with invalid name" do
put :update, params: { :id => @host.id, :host => {:name => ''} }
assert_response :unprocessable_entity, "Can update host with empty name"
assert_not_equal '', @host.name
end

test "should create with valid comment" do
comment = RFauxFactory.gen_alpha
post :create, params: { :host => valid_attrs.merge(:comment => comment) }
assert_response :created
assert_equal JSON.parse(@response.body)['comment'], comment, "Can't create host with valid comment #{comment}"
end

test "should create with enabled parameter" do
post :create, params: { :host => valid_attrs.merge(:enabled => false) }
assert_response :created
assert_equal JSON.parse(@response.body)['enabled'], false, "Can't create host with enabled parameter false"
end

test "should create with managed parameter" do
post :create, params: { :host => valid_attrs.merge(:managed => true) }
assert_response :created
assert_equal JSON.parse(@response.body)['managed'], true, "Can't create host with managed parameter true"
end

test "should create with build provision method" do
post :create, params: { :host => valid_attrs.merge(:provision_method => 'build') }
assert_response :created
assert_equal JSON.parse(@response.body)['provision_method'], 'build', "Can't create host with build provision method"
end

test "should create with image provision method" do
post :create, params: { :host => valid_attrs.merge(:provision_method => 'image') }
assert_response :created
assert_equal JSON.parse(@response.body)['provision_method'], 'image', "Can't create host with image provision method"
end

test "should create with puppet ca proxy" do
smart_proxy = FactoryBot.create(:smart_proxy)
post :create, params: { :host => valid_attrs.merge(:puppet_ca_proxy_id => smart_proxy.id) }
assert_response :created
assert_equal JSON.parse(@response.body)['puppet_ca_proxy']['name'], smart_proxy['name'], "Can't create host with smart proxy #{smart_proxy}"
end

test "should create with puppet proxy" do
post :create, params: { :host => valid_attrs }
assert_response :created
assert_equal JSON.parse(@response.body)['puppet_proxy']['name'], smart_proxies(:puppetmaster).name, "Can't create host with puppet proxy #{smart_proxies(:puppetmaster)}"
end

test "should get per page" do
per_page = rand(1..1000)
get :index, params: { :per_page => per_page }
assert_equal JSON.parse(@response.body)['per_page'], per_page
end

test "should not update with invalid mac" do
mac = RFauxFactory.gen_alpha
put :update, params: { :id => @host.id, :host => {:mac => mac} }
assert_response :unprocessable_entity, "Can update host with invalid mac #{mac}"
end

test "should update build parameter with false value" do
host = FactoryBot.create(:host, valid_attrs.merge(:managed => true, :build => true))
put :update, params: { :id => host.id, :host => { :build => false} }
assert_response :success
assert_equal JSON.parse(@response.body)['build'], false, "Can't update host with false build parameter"
end

test "should update build parameter with true value" do
host = FactoryBot.create(:host, valid_attrs.merge(:managed => true, :build => false))
put :update, params: { :id => host.id, :host => { :build => true} }
assert_response :success
assert_equal JSON.parse(@response.body)['build'], true, "Can't update host with true build parameter"
end

test "should update host with valid comment" do
new_comment = 'another valid comment'
host = FactoryBot.create(:host, valid_attrs.merge(:comment => 'this is a valid comment'))
put :update, params: { :id => host.id, :host => { :comment => new_comment} }
assert_response :success
assert_equal JSON.parse(@response.body)['comment'], new_comment, "Can't update host with valid comment #{new_comment}"
end

test "should update enabled parameter with false value" do
host = FactoryBot.create(:host, valid_attrs.merge(:enabled => true))
put :update, params: { :id => host.id, :host => { :enabled => false} }
assert_response :success
assert_equal JSON.parse(@response.body)['enabled'], false, "Can't update host with false enabled parameter"
end

test "should update enabled parameter with true value" do
host = FactoryBot.create(:host, valid_attrs.merge(:enabled => false))
put :update, params: { :id => host.id, :host => { :enabled => true} }
assert_response :success
assert_equal JSON.parse(@response.body)['enabled'], true, "Can't update host with true enabled parameter"
end

test "should update host with parameters attributes" do
attrs = [{:name => "attr_name", :value => "attr_value"}]
post :create, params: { :id => @host.id, :host => valid_attrs.merge(:host_parameters_attributes => attrs) }
assert_response :success
assert_equal JSON.parse(@response.body)['parameters'][0]['name'], attrs[0][:name], "Can't update host with valid parameters #{attrs}"
assert_equal JSON.parse(@response.body)['parameters'][0]['value'], attrs[0][:value], "Can't update host with valid parameters #{attrs}"
end

test "should update with valid ip" do
ip = RFauxFactory.gen_ipaddr
put :update, params: { :id => @host.id, :host => { :ip => ip} }
assert_response :success
assert_equal JSON.parse(@response.body)['ip'], ip, "Can't update host with valid ip #{ip}"
end

test "should update with valid mac" do
mac = RFauxFactory.gen_mac(multicast: false)
put :update, params: { :id => @host.id, :host => { :mac => mac} }
assert_response :success
assert_equal JSON.parse(@response.body)['mac'], mac, "Can't update host with valid mac #{mac}"
end

test "should update with managed parameter true" do
host = FactoryBot.create(:host, valid_attrs.merge(:managed => false))
put :update, params: { :id => host.id, :host => { :managed => true} }
assert_response :success
assert_equal JSON.parse(@response.body)['managed'], true, "Can't update host with managed parameter true"
end

test "should update with managed parameter true" do
host = FactoryBot.create(:host, valid_attrs.merge(:managed => true))
put :update, params: { :id => host.id, :host => { :managed => false} }
assert_response :success
assert_equal JSON.parse(@response.body)['managed'], false, "Can't update host with managed parameter false"
end

test "should update with valid name" do
name = RFauxFactory.gen_alpha.downcase
put :update, params: { :id => @host.id, :host => { :name => name} }
assert_response :success
assert_equal JSON.parse(@response.body)['name'], name, "Can't update host with valid name #{name}"
end

test "should update with user owner" do
user = FactoryBot.create(:user, :locations => [taxonomies(:location1)], :organizations => [taxonomies(:organization1)])
put :update, params: { :id => @host.id, :host => { :owner_type => 'User', :owner_id => user.id} }
assert_response :success
assert_equal JSON.parse(@response.body)['owner_type'], 'User', "Can't update host with user owner"
assert_equal JSON.parse(@response.body)['owner_id'], user.id, "Can't update host with user #{user}"
end

test "should update with usergroup owner" do
usergroup = FactoryBot.create(:usergroup)
put :update, params: { :id => @host.id, :host => { :owner_type => 'Usergroup', :owner_id => usergroup.id} }
assert_response :success
assert_equal JSON.parse(@response.body)['owner_type'], 'Usergroup', "Can't update host with usergroup owner"
assert_equal JSON.parse(@response.body)['owner_id'], usergroup.id, "Can't update host with usergroup #{usergroup}"
end

test "should update with puppet ca proxy" do
puppet_ca_proxy = FactoryBot.create(:smart_proxy)
put :update, params: { :id => @host.id, :host => valid_attrs.merge(:puppet_ca_proxy_id => puppet_ca_proxy.id) }
assert_response :success
assert_equal JSON.parse(@response.body)['puppet_ca_proxy']['name'], puppet_ca_proxy['name'], "Can't update host with puppet ca proxy #{puppet_ca_proxy}"
end

test "should update with puppet class" do
environment = environments(:testing)
puppetclass = Puppetclass.find_by_name('git')
put :update, params: { :id => @host.id, :host => valid_attrs.merge(:environment_id => environment.id, :puppetclass_ids => [puppetclass.id]) }
assert_response :success
assert_equal JSON.parse(@response.body)['environment_id'], environment.id, "Can't update host with environment #{environment}"
assert_equal JSON.parse(@response.body)['puppetclasses'][0]['id'], puppetclass.id, "Can't update host with puppetclass #{puppetclass}"
end

test "should update with puppet proxy" do
puppet_proxy = FactoryBot.create(:smart_proxy)
put :update, params: { :id => @host.id, :host => valid_attrs.merge(:puppet_proxy_id => puppet_proxy.id) }
assert_response :success
assert_equal JSON.parse(@response.body)['puppet_proxy']['name'], puppet_proxy['name'], "Can't update host with puppet proxy #{puppet_proxy}"
end
0fda4cf6 Joseph Mitchell Magen
end