foreman_discovery 1.0.0 → 1.0.2

data/test/foreman_app/test/functional/api/v1/common_parameters_controller_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-class Api::V1::CommonParametersControllerTest < ActionController::TestCase
-
-  valid_attrs = { :name => 'special_key', :value => '123' }
-
-  test "should get index" do
-    get :index, { }
-    assert_response :success
-    assert_not_nil assigns(:common_parameters)
-    common_parameters = ActiveSupport::JSON.decode(@response.body)
-    assert !common_parameters.empty?
-  end
-
-  test "should show parameter" do
-    get :show, { :id => parameters(:common).to_param }
-    assert_response :success
-    show_response = ActiveSupport::JSON.decode(@response.body)
-    assert !show_response.empty?
-  end
-
-  test "should create common_parameter" do
-    assert_difference('CommonParameter.count') do
-      post :create, { :common_parameter => valid_attrs }
-    end
-    assert_response :success
-  end
-
-  test "should update common_parameter" do
-    put :update, { :id => parameters(:common).to_param, :common_parameter => { } }
-    assert_response :success
-  end
-
-  test "should destroy common_parameter" do
-    assert_difference('CommonParameter.count', -1) do
-      delete :destroy, { :id => parameters(:common).to_param }
-    end
-    assert_response :success
-  end
-
-end

data/test/foreman_app/test/functional/api/v1/compute_resources_controller_test.rb

@@ -1,50 +0,0 @@
-require 'test_helper'
-
-class Api::V1::ComputeResourcesControllerTest < ActionController::TestCase
-
-  def setup
-    Fog.mock!
-  end
-
-  def teardown
-    Fog.unmock!
-  end
-
-  valid_attrs = { :name => 'special_compute', :provider => 'EC2', :region => 'eu-west-1', :user => 'user@example.com', :password => 'secret' }
-
-  test "should get index" do
-    get :index, { }
-    assert_response :success
-    assert_not_nil assigns(:compute_resources)
-    compute_resources = ActiveSupport::JSON.decode(@response.body)
-    assert !compute_resources.empty?
-  end
-
-  test "should show compute_resource" do
-    get :show, { :id => compute_resources(:one).to_param }
-    assert_response :success
-    show_response = ActiveSupport::JSON.decode(@response.body)
-    assert !show_response.empty?
-  end
-
-  test "should create valid compute resource" do
-    post :create, { :compute_resource => valid_attrs }
-    assert_response :success
-    show_response = ActiveSupport::JSON.decode(@response.body)
-    assert !show_response.empty?
-  end
-
-  test "should update compute resource" do
-    put :update, { :id => compute_resources(:mycompute).to_param, :compute_resource => { :description => "new_description" } }
-    assert_equal "new_description", ComputeResource.find_by_name('mycompute').description
-    assert_response :success
-  end
-
-  test "should destroy compute resource" do
-    assert_difference('ComputeResource.count', -1) do
-      delete :destroy, { :id => compute_resources(:yourcompute).id }
-    end
-    assert_response :success
-  end
-
-end

data/test/foreman_app/test/functional/api/v1/config_templates_controller_test.rb

@@ -1,82 +0,0 @@
-require 'test_helper'
-
-class Api::V1::ConfigTemplatesControllerTest < ActionController::TestCase
-
-  valid_attrs = { :template => "This is a test template", :template_kind_id => 1, :name => "RandomName" }
-
-  test "should get index" do
-    get :index
-    templates = ActiveSupport::JSON.decode(@response.body)
-    assert !templates.empty?, "Should response with template"
-    assert_response :success
-  end
-
-  test "should get template detail" do
-    get :show, { :id => ConfigTemplate.first.to_param }
-    assert_response :success
-    template = ActiveSupport::JSON.decode(@response.body)
-    assert !template.empty?
-    assert_equal template["config_template"]["name"], ConfigTemplate.first.name
-  end
-
-  test "should not create invalid" do
-    post :create
-    assert_response 422
-  end
-
-  test "should create valid" do
-    ConfigTemplate.any_instance.stubs(:valid?).returns(true)
-    post :create, { :config_template => valid_attrs }
-    template = ActiveSupport::JSON.decode(@response.body)
-    assert template["config_template"]["name"] == "RandomName"
-    assert_response 200
-  end
-
-  test "should not update invalid" do
-    put :update, { :id              => ConfigTemplate.first.to_param,
-                   :config_template => { :name => "" } }
-    assert_response 422
-  end
-
-  test "should update valid" do
-    ConfigTemplate.any_instance.stubs(:valid?).returns(true)
-    put :update, { :id              => ConfigTemplate.first.to_param,
-                   :config_template => { :template => "blah" } }
-    template = ActiveSupport::JSON.decode(@response.body)
-    assert_response :ok
-  end
-
-  test "should not destroy template with associated hosts" do
-    config_template = ConfigTemplate.first
-    delete :destroy, { :id => config_template.to_param }
-    assert_response 422
-    assert ConfigTemplate.exists?(config_template.id)
-  end
-
-  test "should destroy" do
-    config_template = ConfigTemplate.first
-    config_template.os_default_templates.clear
-    delete :destroy, { :id => config_template.to_param }
-    template = ActiveSupport::JSON.decode(@response.body)
-    assert_response :ok
-    assert !ConfigTemplate.exists?(config_template.id)
-  end
-
-  test "should build pxe menu" do
-
-    ProxyAPI::TFTP.any_instance.stubs(:create_default).returns(true)
-    ProxyAPI::TFTP.any_instance.stubs(:fetch_boot_file).returns(true)
-    get :build_pxe_default
-    assert_response 200
-  end
-
-  test "should add audit comment" do
-    ConfigTemplate.auditing_enabled = true
-    ConfigTemplate.any_instance.stubs(:valid?).returns(true)
-    put :update, { :id              => ConfigTemplate.first.to_param,
-                   :config_template => { :audit_comment => "aha", :template => "tmp" } }
-    assert_response :success
-    assert_equal "aha", ConfigTemplate.first.audits.last.comment
-  end
-
-end

data/test/foreman_app/test/functional/api/v1/dashboard_controller_test.rb

@@ -1,12 +0,0 @@
-require 'test_helper'
-
-class Api::V1::DashboardControllerTest < ActionController::TestCase
-
-  test "should get index with json result" do
-    get :index, { }
-    assert_response :success
-    dashboard = ActiveSupport::JSON.decode(@response.body)
-    assert_operator(dashboard.length, :>, 0)
-  end
-
-end

data/test/foreman_app/test/functional/api/v1/domains_controller_test.rb

@@ -1,50 +0,0 @@
-require 'test_helper'
-
-class Api::V1::DomainsControllerTest < ActionController::TestCase
-  test "should get index" do
-    get :index, { }
-    assert_response :success
-    assert_not_nil assigns(:domains)
-  end
-
-  test "should show domain" do
-    get :show, { :id => Domain.first.to_param }
-    assert_response :success
-    show_response = ActiveSupport::JSON.decode(@response.body)
-    assert !show_response.empty?
-  end
-
-  test "should not create invalid domain" do
-    post :create, { :domain => { :fullname => "" } }
-    assert_response :unprocessable_entity
-  end
-
-  test "should create valid domain" do
-    post :create, { :domain => { :name => "domain.net" } }
-    assert_response :success
-    show_response = ActiveSupport::JSON.decode(@response.body)
-    assert !show_response.empty?
-  end
-
-  test "should update valid domain" do
-    put :update, { :id => Domain.first.to_param, :domain => { :name => "domain.new" } }
-    assert_equal "domain.new", Domain.first.name
-    assert_response :success
-  end
-
-  test "should not update invalid domain" do
-    put :update, { :id => Domain.first.to_param, :domain => { :name => "" } }
-    assert_response :unprocessable_entity
-  end
-
-  test "should destroy domain" do
-    domain = Domain.first
-    domain.hosts.clear
-    domain.hostgroups.clear
-    domain.subnets.clear
-    delete :destroy, { :id => domain.to_param }
-    domain = ActiveSupport::JSON.decode(@response.body)
-    assert_response :ok
-    assert !Domain.exists?(:name => domain['id'])
-  end
-end

data/test/foreman_app/test/functional/api/v1/environments_controller_test.rb

@@ -1,40 +0,0 @@
-require 'test_helper'
-
-class Api::V1::EnvironmentsControllerTest < ActionController::TestCase
-
-  development_environment = { :name => 'Development' }
-
-  test "should get index" do
-    get :index, { }
-    assert_response :success
-    assert_not_nil assigns(:environments)
-    envs = ActiveSupport::JSON.decode(@response.body)
-    assert !envs.empty?
-  end
-
-  test "should show environment" do
-    get :show, { :id => environments(:production).to_param }
-    assert_response :success
-    show_response = ActiveSupport::JSON.decode(@response.body)
-    assert !show_response.empty?
-  end
-
-  test "should create environment" do
-    assert_difference('Environment.count') do
-      post :create, { :environment => development_environment }
-    end
-    assert_response :success
-  end
-
-  test "should update environment" do
-    put :update, { :id => environments(:production).to_param, :environment => { } }
-    assert_response :success
-  end
-
-  test "should destroy environments" do
-    assert_difference('Environment.count', -1) do
-      delete :destroy, { :id => environments(:testing).to_param }
-    end
-    assert_response :success
-  end
-end

data/test/foreman_app/test/functional/api/v1/fact_values_controller_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-
-class Api::V1::FactValuesControllerTest < ActionController::TestCase
-
-  test "should get index" do
-    get :index, { }
-    assert_response :success
-    fact_values = ActiveSupport::JSON.decode(@response.body)
-    assert !fact_values.empty?
-  end
-
-  test "should get facts for given host only" do
-    get :index, {:host_id => hosts(:one).to_param }
-    assert_response :success
-    fact_values = ActiveSupport::JSON.decode(@response.body)
-    assert !fact_values.empty?
-  end
-
-end

data/test/foreman_app/test/functional/api/v1/home_controller_test.rb

@@ -1,11 +0,0 @@
-require 'test_helper'
-
-class Api::V1::HomeControllerTest < ActionController::TestCase
-
-  test "should get index" do
-    get :index, { }
-    assert_response :success
-  end
-
-end
-

data/test/foreman_app/test/functional/api/v1/hostgroups_controller_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-class Api::V1::HostgroupsControllerTest < ActionController::TestCase
-
-  valid_attrs = { :name => 'TestHostgroup' }
-
-  test "should get index" do
-    get :index, { }
-    assert_response :success
-    assert_not_nil assigns(:hostgroups)
-    hostgroups = ActiveSupport::JSON.decode(@response.body)
-    assert !hostgroups.empty?
-  end
-
-  test "should show individual record" do
-    get :show, { :id => hostgroups(:common).to_param }
-    assert_response :success
-    show_response = ActiveSupport::JSON.decode(@response.body)
-    assert !show_response.empty?
-  end
-
-  test "should create hostgroup" do
-    assert_difference('Hostgroup.count') do
-      post :create, { :hostgroup => valid_attrs }
-    end
-    assert_response :success
-  end
-
-  test "should update hostgroup" do
-    put :update, { :id => hostgroups(:common).to_param, :hostgroup => { } }
-    assert_response :success
-  end
-
-  test "should destroy hostgroups" do
-    assert_difference('Hostgroup.count', -1) do
-      delete :destroy, { :id => hostgroups(:common).to_param }
-    end
-    assert_response :success
-  end
-
-end

data/test/foreman_app/test/functional/api/v1/hosts_controller_test.rb

@@ -1,66 +0,0 @@
-require 'test_helper'
-
-class Api::V1::HostsControllerTest < ActionController::TestCase
-
-  def valid_attrs
-    { :name               => 'testhost11',
-      :environment_id     => environments(:production).id,
-      :domain_id          => domains(:mydomain).id,
-      :ip                 => '10.0.0.20',
-      :mac                => '52:53:00:1e:85:93',
-      :architecture_id    => Architecture.find_by_name('x86_64').id,
-      :operatingsystem_id => Operatingsystem.find_by_name('Redhat').id,
-      :puppet_proxy_id    => 7
-    }
-  end
-
-  test "should get index" do
-    get :index, { }
-    assert_response :success
-    assert_not_nil assigns(:hosts)
-    hosts = ActiveSupport::JSON.decode(@response.body)
-    assert !hosts.empty?
-  end
-
-  test "should show individual record" do
-    get :show, { :id => hosts(:one).to_param }
-    assert_response :success
-    show_response = ActiveSupport::JSON.decode(@response.body)
-    assert !show_response.empty?
-  end
-
-  test "should create host" do
-    disable_orchestration
-    assert_difference('Host.count') do
-      post :create, { :host => valid_attrs }
-    end
-    assert_response :success
-    last_host = Host.order('id desc').last
-  end
-
-  test "should create host with managed is false if parameter is passed" do
-    disable_orchestration
-    post :create, { :host => valid_attrs.merge!(:managed => false) }
-    assert_response :success
-    last_host = Host.order('id desc').last
-    assert_equal false, last_host.managed?
-  end
-
-  test "should update host" do
-    put :update, { :id => hosts(:two).to_param, :host => { } }
-    assert_response :success
-  end
-
-  test "should destroy hosts" do
-    assert_difference('Host.count', -1) do
-      delete :destroy, { :id => hosts(:one).to_param }
-    end
-    assert_response :success
-  end
-
-  test "should show status hosts" do
-    get :status, { :id => hosts(:one).to_param }
-    assert_response :success
-  end
-
-end

data/test/foreman_app/test/functional/api/v1/images_controller_test.rb

@@ -1,47 +0,0 @@
-require 'test_helper'
-
-class Api::V1::ImagesControllerTest < ActionController::TestCase
-
-  def valid_attrs
-    { :name                => 'TestImage', :username => 'ec2-user', :uuid => 'abcdef',
-      :operatingsystem_id  => Operatingsystem.first.id,
-      :compute_resource_id => ComputeResource.first.id,
-      :architecture_id     => Architecture.first.id,
-    }
-  end
-
-  test "should get index" do
-    get :index, { :compute_resource_id => images(:two).compute_resource_id }
-    assert_response :success
-    assert_not_nil assigns(:images)
-    images = ActiveSupport::JSON.decode(@response.body)
-    assert !images.empty?
-  end
-
-  test "should show individual record" do
-    get :show, { :compute_resource_id => images(:two).compute_resource_id, :id => images(:one).to_param }
-    assert_response :success
-    show_response = ActiveSupport::JSON.decode(@response.body)
-    assert !show_response.empty?
-  end
-
-  test "should create image" do
-    assert_difference('Image.count') do
-      post :create, { :compute_resource_id => images(:two).compute_resource_id, :image => valid_attrs }
-    end
-    assert_response :success
-  end
-
-  test "should update image" do
-    put :update, { :compute_resource_id => images(:two).compute_resource_id, :id => images(:one).to_param, :image => { } }
-    assert_response :success
-  end
-
-  test "should destroy images" do
-    assert_difference('Image.count', -1) do
-      delete :destroy, { :compute_resource_id => images(:two).compute_resource_id, :id => images(:one).to_param }
-    end
-    assert_response :success
-  end
-
-end