foreman_datacenter 1.22.1 → 1.24.2

data/test/controllers/foreman_datacenter/devices_controller_test.rb

@@ -0,0 +1,132 @@
+require_relative '../../test_plugin_helper'
+
+module ForemanDatacenter
+  class DevicesControllerTest < ActionController::TestCase
+    describe ForemanDatacenter::DevicesController do
+      setup do
+        @model = ForemanDatacenter::Device.first
+      end
+
+      basic_index_test 'devices'
+      basic_new_test
+      basic_edit_test 'device'
+      basic_pagination_per_page_test
+      basic_pagination_rendered_test
+
+      # def test_create_invalid
+      #   ForemanDatacenter::Device.any_instance.stubs(:valid?).returns(false)
+      #   post :create, params: { device: { name: nil } }, session: set_session_user
+      #   assert_template 'new'
+      # end
+
+     #  def test_create_valid(name = "test rg")
+     #    ForemanDatacenter::Device.any_instance.stubs(:valid?).returns(true)
+     #    post :create, params: { device: { name: name } }, session: set_session_user
+     #    assert_redirected_to devices_url
+     #  end
+
+     #  def test_update_invalid
+     #    ForemanDatacenter::Device.any_instance.stubs(:valid?).returns(false)
+     #    put :update, params: { id: @model.to_param, device: { name: '3243' } }, session: set_session_user
+     #    assert_template 'edit'
+     #  end
+
+     #  def test_update_valid
+     #    ForemanDatacenter::Device.any_instance.stubs(:valid?).returns(true)
+     #    put :update, params: { id: @model.to_param, device: { name: @model.name } }, session: set_session_user
+     #    assert_redirected_to devices_url
+     #  end
+
+     #  def test_destroy
+     #    test_create_valid "tobedeleted_test"
+     #    @new_rg = ForemanDatacenter::Device.find_by_name("tobedeleted_test")
+     #    delete :destroy, params: { id: @new_rg.id }, session: set_session_user
+     #    assert_redirected_to devices_url
+     #    assert !ForemanDatacenter::Device.exists?(@new_rg.id)
+     #  end
+
+     #  test "should not get index when not permitted" do
+     #    setup_user
+     #    get :index, session: { :user => users(:one).id, :expires_at => 5.minutes.from_now }
+     #    assert_response :forbidden
+     #    assert_includes @response.body, 'view_devices'
+     #  end
+
+     #  test 'should not get show when not permitted' do
+     #    setup_user
+     #    get :show, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+     #    assert_response :forbidden
+     #    assert_includes @response.body, 'view_devices'
+     #  end
+
+     #  test 'should not get edit when not permitted' do
+     #    setup_user
+     #    get :edit, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+     #    assert_response :forbidden
+     #    assert_includes @response.body, 'edit_devices'
+     #  end
+
+     #  test "should get index" do
+     #    setup_user("Viewer")
+     #    get :index, session: set_session_user
+     #    assert_response :success
+     #    assert_template 'index'
+     #  end
+
+     #  test 'should get show' do
+     #    setup_user("Viewer")
+     #    get :show, params: { :id => @model.id }, session: set_session_user
+     #    assert_response :success
+     #    assert_template 'show'
+     #  end
+
+     #  test 'should not get edit with viewer permissions' do
+     #    setup_user("Viewer")
+     #    get :edit, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+     #    assert_response :forbidden
+     #    assert_includes @response.body, 'edit_devices'
+     #  end
+
+     # test 'should get edit' do
+     #    get :edit, params: { :id => @model.id }, session: set_session_user
+     #    assert_response :success
+     #    assert_template 'edit'
+     #  end
+
+     #  def setup_user(role = "")
+     #    @request.session[:user] = users(:one).id
+     #    users(:one).roles       = [Role.default]
+     #    users(:one).roles << Role.find_by_name(role) if role != ""
+     #    # users(:one).roles       = [Role.default, Role.find_by_name("Viewer")]
+     #  end
+
+     #  test "should_render_404_when_rack_is_not_found" do
+     #    get :show, params: { id: 'no.such.rack.group' }, session: set_session_user
+     #    assert_response :not_found
+     #    assert_template 'common/404'
+     #  end
+
+     #  test "should_not_destroy_device_when_not_permitted" do
+     #    setup_user
+     #    assert_difference('ForemanDatacenter::Device.count', 0) do
+     #      delete :destroy, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+     #    end
+     #    assert_response :forbidden
+     #  end
+
+     #  test "should search by name" do
+     #    get :index, params: {:search => "name=\"device_1\""}, session: set_session_user
+     #    assert_response :success
+     #    refute_empty assigns(:devices)
+     #    assert assigns(:devices).include?(devices(:one)) 
+     #  end
+
+     #  test "should search by site" do
+     #    get :index, params: {:search => "site=\"site_1\""}, session: set_session_user
+     #    assert_response :success
+     #    refute_empty assigns(:devices)
+     #    assert assigns(:devices).include?(devices(:one)) 
+     #  end
+    end
+  end
+end

data/test/controllers/foreman_datacenter/manufacturers_controller_test.rb

@@ -0,0 +1,133 @@
+require_relative '../../test_plugin_helper'
+
+module ForemanDatacenter
+  class ManufacturersControllerTest < ActionController::TestCase
+    describe ForemanDatacenter::ManufacturersController do
+      setup do
+        @model = ForemanDatacenter::Manufacturer.first
+      end
+
+      basic_index_test 'manufacturers'
+      basic_new_test
+      basic_edit_test 'manufacturer'
+      basic_pagination_per_page_test
+      basic_pagination_rendered_test
+
+      def test_create_invalid
+        ForemanDatacenter::Manufacturer.any_instance.stubs(:valid?).returns(false)
+        post :create, params: { :manufacturer => {:name => nil} }, session: set_session_user
+        assert_template 'new'
+      end
+
+      def test_create_valid(name = "test manufacturer")
+        ForemanDatacenter::Manufacturer.any_instance.stubs(:valid?).returns(true)
+        post :create, params: { :manufacturer => {:name => name} }, session: set_session_user
+        assert_redirected_to manufacturers_url
+      end
+
+      def test_update_invalid
+        ForemanDatacenter::Manufacturer.any_instance.stubs(:valid?).returns(false)
+        put :update, params: { :id => @model.to_param, :manufacturer => {:name => "3243"} }, session: set_session_user
+        assert_template 'edit'
+      end
+
+      def test_update_valid
+        ForemanDatacenter::Manufacturer.any_instance.stubs(:valid?).returns(true)
+        put :update, params: { :id => @model.to_param, :manufacturer => {:name => @model.name} }, session: set_session_user
+        assert_redirected_to manufacturers_url
+      end
+
+      def test_destroy
+        test_create_valid "tobedeleted_test"
+        @new_manufacturer = ForemanDatacenter::Manufacturer.find_by_name("tobedeleted_test")
+        delete :destroy, params: { :id => @new_manufacturer.id }, session: set_session_user
+        assert_redirected_to manufacturers_url
+        assert !ForemanDatacenter::Manufacturer.exists?(@new_manufacturer.id)
+      end
+
+      def test_destroy
+        test_create_valid "tobedeleted_test"
+        @new_manufacturer = ForemanDatacenter::Manufacturer.find_by_name("tobedeleted_test")
+        delete :destroy, params: { :id => @new_manufacturer.id }, session: set_session_user
+        assert_redirected_to manufacturers_url
+        assert !ForemanDatacenter::Manufacturer.exists?(@new_manufacturer.id)
+      end
+
+      test "should not get index when not permitted" do
+        setup_user
+        get :index, session: { :user => users(:one).id, :expires_at => 5.minutes.from_now }
+        assert_response :forbidden
+        assert_includes @response.body, 'view_manufacturers'
+      end
+
+      test 'should not get show when not permitted' do
+        setup_user
+        get :show, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+        assert_response :forbidden
+        assert_includes @response.body, 'view_manufacturers'
+      end
+
+      test 'should not get edit when not permitted' do
+        setup_user
+        get :edit, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+        assert_response :forbidden
+        assert_includes @response.body, 'edit_manufacturers'
+      end
+
+      test "should get index" do
+        setup_user("Viewer")
+        get :index, session: set_session_user
+        assert_response :success
+        assert_template 'index'
+      end
+
+      test 'should get show' do
+        setup_user("Viewer")
+        get :show, params: { :id => @model.id }, session: set_session_user
+        assert_response :success
+        assert_template 'show'
+      end
+
+      test 'should not get edit with viewer permissions' do
+        setup_user("Viewer")
+        get :edit, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+        assert_response :forbidden
+        assert_includes @response.body, 'edit_manufacturers'
+      end
+
+     test 'should get edit' do
+        get :edit, params: { :id => @model.id }, session: set_session_user
+        assert_response :success
+        assert_template 'edit'
+      end
+
+      def setup_user(role = "")
+        @request.session[:user] = users(:one).id
+        users(:one).roles       = [Role.default]
+        users(:one).roles << Role.find_by_name(role) if role != ""
+        # users(:one).roles       = [Role.default, Role.find_by_name("Viewer")]
+      end
+
+      test "should_render_404_when_manufacturer_is_not_found" do
+        get :show, params: { id: 'no.such.manufacturer' }, session: set_session_user
+        assert_response :not_found
+        assert_template 'common/404'
+      end
+
+      test "should_not_destroy_manufacturer_when_not_permitted" do
+        setup_user
+        assert_difference('ForemanDatacenter::Manufacturer.count', 0) do
+          delete :destroy, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+        end
+        assert_response :forbidden
+      end
+
+      test "should search by name" do
+        get :index, params: {:search => "name=\"manufacturer_1\""}, session: set_session_user
+        assert_response :success
+        refute_empty assigns(:manufacturers)
+        assert assigns(:manufacturers).include?(manufacturers(:one)) 
+      end
+    end
+  end
+end

data/test/controllers/foreman_datacenter/platforms_contoller_test.rb

@@ -13,84 +13,127 @@ module ForemanDatacenter
       basic_pagination_per_page_test
       basic_pagination_rendered_test
 
-      def test_new_submit_button_id
-        get :new, session: set_session_user
-        assert_select "[data-id='aid_datacenter_platforms']"
-      end
-
-      def test_new_cancel_button_id
-        get :new, session: set_session_user
-        assert_select "[data-id='aid_datacenter_platforms']"
-      end
-      
-      def test_show_edit_button_id
-        get :show, params: { :id => ForemanDatacenter::Platform.first.to_param }, session: set_session_user
-        assert_select "[data-id='aid_platforms_#{ForemanDatacenter::Platform.first.id}_edit']"
-      end
-
-      def test_show_delete_button_id
-        get :show, params: { :id => ForemanDatacenter::Platform.first.to_param }, session: set_session_user
-        assert_select "[data-id='aid_datacenter_platforms_#{ForemanDatacenter::Platform.first.id}']"
-      end
-
-      test "should_show_platform" do
-        setup_user
-        get :show, params: { :id => ForemanDatacenter::Platform.first.to_param }, session: set_session_user
-        assert_response :success
-      end
-
       def test_create_invalid
         ForemanDatacenter::Platform.any_instance.stubs(:valid?).returns(false)
         post :create, params: { :platform => {:name => nil} }, session: set_session_user
         assert_template 'new'
       end
 
-      def test_create_valid
+      def test_create_valid(name = "test platform")
         ForemanDatacenter::Platform.any_instance.stubs(:valid?).returns(true)
-        post :create, params: { :platform => {:name => 'test site'} }, session: set_session_user
+        post :create, params: { :platform => {:name => name} }, session: set_session_user
         assert_redirected_to platforms_url
       end
 
-      def test_edit_submit_button_id
-        get :edit, params: { :id => ForemanDatacenter::Platform.first }, session: set_session_user
-        assert_select "[data-id='aid_update_foreman_datacenter_platform']"
-      end
-
       def test_update_invalid
         ForemanDatacenter::Platform.any_instance.stubs(:valid?).returns(false)
-        put :update, params: { :id => ForemanDatacenter::Platform.first.to_param, :platform => {:name => "3243", :asn => "string"} }, session: set_session_user
+        put :update, params: { :id => @model.to_param, :platform => {:name => "3243"} }, session: set_session_user
         assert_template 'edit'
       end
 
       def test_update_valid
         ForemanDatacenter::Platform.any_instance.stubs(:valid?).returns(true)
-        put :update, params: { :id => ForemanDatacenter::Platform.first.to_param, :platform => {:name => ForemanDatacenter::Site.first.name} }, session: set_session_user
+        put :update, params: { :id => @model.to_param, :platform => {:name => @model.name} }, session: set_session_user
         assert_redirected_to platforms_url
       end
 
-      # def test_destroy
-      #   platform = ForemanDatacenter::Platform.first
-      #   # architecture.hosts.delete_all
-      #   # architecture.hostgroups.delete_all
-      #   delete :destroy, params: { :id => platform }, session: set_session_user
-      #   assert_redirected_to platforms_url
-      #   assert !ForemanDatacenter::Platform.exists?(platform.id)
-      # end
+      def test_destroy
+        test_create_valid "tobedeleted_test"
+        @new_platform = ForemanDatacenter::Platform.find_by_name("tobedeleted_test")
+        delete :destroy, params: { :id => @new_platform.id }, session: set_session_user
+        assert_redirected_to platforms_url
+        assert !ForemanDatacenter::Platform.exists?(@new_platform.id)
+      end
 
       test '403 response contains missing permissions' do
         setup_user
-        get :edit, params: { :id => ForemanDatacenter::Platform.first.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+        get :edit, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
         assert_response :forbidden
         assert_includes @response.body, 'edit_platforms'
       end
 
-      def setup_user
+
+      test "should not get index when not permitted" do
+        setup_user
+        get :index, session: { :user => users(:one).id, :expires_at => 5.minutes.from_now }
+        assert_response :forbidden
+        assert_includes @response.body, 'view_platforms'
+      end
+
+      test 'should not get show when not permitted' do
+        setup_user
+        get :show, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+        assert_response :forbidden
+        assert_includes @response.body, 'view_platforms'
+      end
+
+      test 'should not get edit when not permitted' do
+        setup_user
+        get :edit, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+        assert_response :forbidden
+        assert_includes @response.body, 'edit_platforms'
+      end
+
+      test "should get index" do
+        setup_user("Viewer")
+        get :index, session: set_session_user
+        assert_response :success
+        assert_template 'index'
+      end
+
+      test 'should get show' do
+        setup_user("Viewer")
+        get :show, params: { :id => @model.id }, session: set_session_user
+        assert_response :success
+        assert_template 'show'
+      end
+
+      test 'should not get edit with viewer permissions' do
+        setup_user("Viewer")
+        get :edit, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+        assert_response :forbidden
+        assert_includes @response.body, 'edit_platforms'
+      end
+
+     test 'should get edit' do
+        get :edit, params: { :id => @model.id }, session: set_session_user
+        assert_response :success
+        assert_template 'edit'
+      end
+
+      def setup_user(role = "")
         @request.session[:user] = users(:one).id
-        users(:one).roles       = [Role.default, Role.find_by_name('Viewer')]
+        users(:one).roles       = [Role.default]
+        users(:one).roles << Role.find_by_name(role) if role != ""
+        # users(:one).roles       = [Role.default, Role.find_by_name("Viewer")]
       end
 
-      def get_factory_name
-        :platform
+      test "should_render_404_when_platform_is_not_found" do
+        get :show, params: { id: 'no.such.platform' }, session: set_session_user
+        assert_response :not_found
+        assert_template 'common/404'
+      end
+
+      test "should_not_destroy_rack_when_not_permitted" do
+        setup_user
+        assert_difference('ForemanDatacenter::Platform.count', 0) do
+          delete :destroy, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+        end
+        assert_response :forbidden
+      end
+
+      test "should search by name" do
+        get :index, params: {:search => "name=\"platform_1\""}, session: set_session_user
+        assert_response :success
+        refute_empty assigns(:platforms)
+        assert assigns(:platforms).include?(platforms(:one))
+      end
+
+      test "should search by rpc client" do
+        get :index, params: {:search => "rpc_client=\"Juniper Junos (NETCONF)\""}, session: set_session_user
+        assert_response :success
+        refute_empty assigns(:platforms)
+        assert assigns(:platforms).include?(platforms(:one))
       end
     end
   end

data/test/controllers/foreman_datacenter/rack_groups_contoller_test.rb

@@ -5,7 +5,6 @@ module ForemanDatacenter
     describe ForemanDatacenter::RackGroupsController do
       setup do
         @model = ForemanDatacenter::RackGroup.first
-        # @factory_options = :with_site
       end
 
       basic_index_test 'rack_groups'
@@ -14,71 +13,119 @@ module ForemanDatacenter
       basic_pagination_per_page_test
       basic_pagination_rendered_test
 
-      def test_new_submit_button_id
-        get :new, session: set_session_user
-        assert_select "[data-id='aid_datacenter_rack_groups']"
-      end
-
-      def test_new_cancel_button_id
-        get :new, session: set_session_user
-        assert_select "[data-id='aid_datacenter_rack_groups']"
-      end
-
-      def test_show_edit_button_id
-        get :show, params: { :id => ForemanDatacenter::RackGroup.first.to_param }, session: set_session_user
-        assert_select "[data-id='aid_rack_groups_#{ForemanDatacenter::RackGroup.first.id}_edit']"
-      end
-
-      def test_show_delete_button_id
-        get :show, params: { :id => ForemanDatacenter::RackGroup.first.to_param }, session: set_session_user
-        assert_select "[data-id='aid_datacenter_rack_groups_#{ForemanDatacenter::RackGroup.first.id}']"
-      end
-
       def test_create_invalid
         ForemanDatacenter::RackGroup.any_instance.stubs(:valid?).returns(false)
-        post :create, params: { :rack_group => {:name => nil} }, session: set_session_user
+        post :create, params: { rack_group: { name: nil } }, session: set_session_user
         assert_template 'new'
       end
 
-      def test_create_valid
+      def test_create_valid(name = "test rg")
         ForemanDatacenter::RackGroup.any_instance.stubs(:valid?).returns(true)
-        post :create, params: { :rack_group => {:name => 'test rg'} }, session: set_session_user
+        post :create, params: { rack_group: { name: name } }, session: set_session_user
         assert_redirected_to rack_groups_url
       end
 
-      def test_edit_submit_button_id
-        get :edit, params: { :id => ForemanDatacenter::RackGroup.first }, session: set_session_user
-        assert_select "[data-id='aid_update_foreman_datacenter_rack_group']"
-      end
-
       def test_update_invalid
         ForemanDatacenter::RackGroup.any_instance.stubs(:valid?).returns(false)
-        put :update, params: { :id => ForemanDatacenter::RackGroup.first.to_param, :rack_group => {:name => "3243"} }, session: set_session_user
+        put :update, params: { id: @model.to_param, rack_group: { name: '3243' } }, session: set_session_user
         assert_template 'edit'
       end
 
       def test_update_valid
         ForemanDatacenter::RackGroup.any_instance.stubs(:valid?).returns(true)
-        put :update, params: { :id => ForemanDatacenter::RackGroup.first.to_param, :rack_group => {:name => ForemanDatacenter::RackGroup.first.name} }, session: set_session_user
+        put :update, params: { id: @model.to_param, rack_group: { name: @model.name } }, session: set_session_user
+        assert_redirected_to rack_groups_url
+      end
+
+      def test_destroy
+        test_create_valid "tobedeleted_test"
+        @new_rg = ForemanDatacenter::RackGroup.find_by_name("tobedeleted_test")
+        delete :destroy, params: { id: @new_rg.id }, session: set_session_user
         assert_redirected_to rack_groups_url
+        assert !ForemanDatacenter::RackGroup.exists?(@new_rg.id)
       end
 
-      # def test_destroy
-      #   rack_group = ForemanDatacenter::RackGroup.first
-      #   # architecture.hosts.delete_all
-      #   # architecture.hostgroups.delete_all
-      #   delete :destroy, params: { :id => rack_group }, session: set_session_user
-      #   assert_redirected_to rack_groups_url
-      #   assert !ForemanDatacenter::RackGroup.exists?(rack_group.id)
-      # end
+      test "should not get index when not permitted" do
+        setup_user
+        get :index, session: { :user => users(:one).id, :expires_at => 5.minutes.from_now }
+        assert_response :forbidden
+        assert_includes @response.body, 'view_rack_groups'
+      end
+
+      test 'should not get show when not permitted' do
+        setup_user
+        get :show, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+        assert_response :forbidden
+        assert_includes @response.body, 'view_rack_groups'
+      end
 
-      def setup_user
+      test 'should not get edit when not permitted' do
+        setup_user
+        get :edit, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+        assert_response :forbidden
+        assert_includes @response.body, 'edit_rack_groups'
+      end
+
+      test "should get index" do
+        setup_user("Viewer")
+        get :index, session: set_session_user
+        assert_response :success
+        assert_template 'index'
+      end
+
+      test 'should get show' do
+        setup_user("Viewer")
+        get :show, params: { :id => @model.id }, session: set_session_user
+        assert_response :success
+        assert_template 'show'
+      end
+
+      test 'should not get edit with viewer permissions' do
+        setup_user("Viewer")
+        get :edit, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+        assert_response :forbidden
+        assert_includes @response.body, 'edit_rack_groups'
+      end
+
+     test 'should get edit' do
+        get :edit, params: { :id => @model.id }, session: set_session_user
+        assert_response :success
+        assert_template 'edit'
+      end
+
+      def setup_user(role = "")
         @request.session[:user] = users(:one).id
-        users(:one).roles       = [Role.default, Role.find_by_name('Viewer')]
+        users(:one).roles       = [Role.default]
+        users(:one).roles << Role.find_by_name(role) if role != ""
+        # users(:one).roles       = [Role.default, Role.find_by_name("Viewer")]
+      end
+
+      test "should_render_404_when_rack_is_not_found" do
+        get :show, params: { id: 'no.such.rack.group' }, session: set_session_user
+        assert_response :not_found
+        assert_template 'common/404'
+      end
+
+      test "should_not_destroy_rack_group_when_not_permitted" do
+        setup_user
+        assert_difference('ForemanDatacenter::RackGroup.count', 0) do
+          delete :destroy, params: { :id => @model.id }, session: {:user => users(:one).id, :expires_at => 5.minutes.from_now}
+        end
+        assert_response :forbidden
+      end
+
+      test "should search by name" do
+        get :index, params: {:search => "name=\"rack_group_1\""}, session: set_session_user
+        assert_response :success
+        refute_empty assigns(:rack_groups)
+        assert assigns(:rack_groups).include?(rack_groups(:one))
       end
 
-      def get_factory_name
-        :rack_group
+      test "should search by site" do
+        get :index, params: {:search => "site=\"site_1\""}, session: set_session_user
+        assert_response :success
+        refute_empty assigns(:rack_groups)
+        assert assigns(:rack_groups).include?(rack_groups(:one))
       end
     end
   end