foreman_datacenter 1.24.0 → 1.24.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b31588dc6a151742a438a98274b00ee81f4a3c8143908585f5e370a23a415548
-  data.tar.gz: cd83b79baba8e169481b049df1c1d691da1fa1d9d2bac8d42742578deaf58f24
+  metadata.gz: d92338ad9dbcbb8535e563a11151dc94e5f0cf0e4ca2b67aaa80cc025bf553e5
+  data.tar.gz: 0a26582a81e88b47f3205cfe9ab278cfc7e809a864d4e1f9b4cf73ce6ccb0a82
 SHA512:
-  metadata.gz: ae8cd3fffb336f93af36419e7a8ebf7e43e8f067da22e9a0492ca89b463cf3e0dde558808d028534dc145bb2e1be7d05a6ae2cf6519f1b13188dd016fa7b9479
-  data.tar.gz: 3343207b606cf6d557bf2a16816b7b3f701a665bd688ffe8dd4593eb23cfdeee7306118ce84fd5f64843cd3fb3b69d1fc614045c85095a609fecb6d60aa2acd0
+  metadata.gz: 829d263770d9b13f7f31ac94142e53654036eb7499debac6855e3287215d7afc389e62de47c0fe97fcc1cfd881e185887d1d765f66b62d666f9a46a32d5dcbf3
+  data.tar.gz: 0e76d5be4b412cd6f3df9890ef45d36a5465f7b7f1ad55b1c07b2472670d5ef414e176af5f8133e311f491675a1540de09cd70da8e0ed47b4f67b14e9bfb781f

data/lib/foreman_datacenter/version.rb

@@ -1,3 +1,3 @@
 module ForemanDatacenter
-  VERSION = '1.24.0'.freeze
+  VERSION = '1.24.1'.freeze
 end

data/test/controllers/foreman_datacenter/device_roles_controller_test.rb

@@ -0,0 +1,133 @@
+require_relative '../../test_plugin_helper'
+
+module ForemanDatacenter
+  class DeviceRolesControllerTest < ActionController::TestCase
+    describe ForemanDatacenter::DeviceRolesController do
+      setup do
+        @model = ForemanDatacenter::DeviceRole.first
+      end
+
+      basic_index_test 'device_roles'
+      basic_new_test
+      basic_edit_test 'device_role'
+      basic_pagination_per_page_test
+      basic_pagination_rendered_test
+
+      def test_create_invalid
+        ForemanDatacenter::DeviceRole.any_instance.stubs(:valid?).returns(false)
+        post :create, params: { :device_role => {:name => nil} }, session: set_session_user
+        assert_template 'new'
+      end
+
+      def test_create_valid(name = "test device_role")
+        ForemanDatacenter::DeviceRole.any_instance.stubs(:valid?).returns(true)
+        post :create, params: { :device_role => {:name => name, :color => 'Teal'} }, session: set_session_user
+        assert_redirected_to device_roles_url
+      end
+
+      def test_update_invalid
+        ForemanDatacenter::DeviceRole.any_instance.stubs(:valid?).returns(false)
+        put :update, params: { :id => @model.to_param, :device_role => {:name => "3243", :color => "Red"} }, session: set_session_user
+        assert_template 'edit'
+      end
+
+      def test_update_valid
+        ForemanDatacenter::DeviceRole.any_instance.stubs(:valid?).returns(true)
+        put :update, params: { :id => @model.to_param, :device_role => {:name => @model.name, :color => "Green"} }, session: set_session_user
+        assert_redirected_to device_roles_url
+      end
+
+      def test_destroy
+        test_create_valid "tobedeleted_test"
+        @new_dr = ForemanDatacenter::DeviceRole.find_by_name("tobedeleted_test")
+        delete :destroy, params: { :id => @new_dr.id }, session: set_session_user
+        assert_redirected_to device_roles_url
+        assert !ForemanDatacenter::DeviceRole.exists?(@new_dr.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_device_roles'
+      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_device_roles'
+      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_device_roles'
+      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_device_roles'
+      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_device_role_is_not_found" do
+        get :show, params: { id: 'no.such.device.role' }, session: set_session_user
+        assert_response :not_found
+        assert_template 'common/404'
+      end
+
+      test "should_not_destroy_device_role_when_not_permitted" do
+        setup_user
+        assert_difference('ForemanDatacenter::DeviceRole.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_role_1\""}, session: set_session_user
+        assert_response :success
+        refute_empty assigns(:device_roles)
+        assert assigns(:device_roles).include?(device_roles(:one)) 
+      end
+
+     test "should search by color" do
+        get :index, params: {:search => "color=\"Teal\""}, session: set_session_user
+        assert_response :success
+        refute_empty assigns(:device_roles)
+        assert assigns(:device_roles).include?(device_roles(:one)) 
+      end
+   
+    end
+  end
+end

data/test/controllers/foreman_datacenter/device_types_contoller_test.rb

@@ -13,78 +13,139 @@ 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_device_types']"
-      end
+      def test_create_invalid
+        ForemanDatacenter::DeviceType.any_instance.stubs(:valid?).returns(false)
+        post :create, params: { device_type: { model: nil } }, session: set_session_user
+        assert_template 'new'
+         end
 
-      def test_new_cancel_button_id
-        get :new, session: set_session_user
-        assert_select "[data-id='aid_datacenter_device_types']"
-      end
-      
-      def test_show_edit_button_id
-        get :show, params: { :id => ForemanDatacenter::DeviceType.first.to_param }, session: set_session_user
-        assert_select "[data-id='aid_device_types_#{ForemanDatacenter::DeviceType.first.id}_edit']"
+      def test_create_valid(model = "test device_type")
+        ForemanDatacenter::DeviceType.any_instance.stubs(:valid?).returns(true)
+        post :create, params: { device_type: { model: model, manufacturer_id: 1 } }, session: set_session_user
+        assert_redirected_to device_types_url
       end
 
-      def test_show_delete_button_id
-        get :show, params: { :id => ForemanDatacenter::DeviceType.first.to_param }, session: set_session_user
-        assert_select "[data-id='aid_datacenter_device_types_#{ForemanDatacenter::DeviceType.first.id}']"
+      def test_update_invalid
+        ForemanDatacenter::DeviceType.any_instance.stubs(:valid?).returns(false)
+        put :update, params: { id: @model.to_param, device_type: { model: '3243', color: 'Red' } }, session: set_session_user
+        assert_template 'edit'
       end
 
-      test "should_show_device_type" do
-        setup_user
-        get :show, params: { :id => ForemanDatacenter::DeviceType.first.to_param }, session: set_session_user
-        assert_response :success
+      def test_update_valid
+        ForemanDatacenter::DeviceType.any_instance.stubs(:valid?).returns(true)
+        put :update, params: { id: @model.to_param, device_type: { model: @model.model, color: 'Green' } }, session: set_session_user
+        assert_redirected_to device_types_url
       end
 
       def test_create_invalid
         ForemanDatacenter::DeviceType.any_instance.stubs(:valid?).returns(false)
-        post :create, params: { :device_type => {:model => nil} }, session: set_session_user
+        post :create, params: { device_type: { model: nil } }, session: set_session_user
         assert_template 'new'
       end
 
-      def test_create_valid
-        ForemanDatacenter::DeviceType.any_instance.stubs(:valid?).returns(true)
-        post :create, params: { :device_type => {:model => 'test model'} }, session: set_session_user
-        # assert_redirected_to device_types_url
-        # assert_redirected_to device_type_url(ForemanDatacenter::DeviceType.first)
+      def test_destroy
+        test_create_valid "tobedeleted_test"
+        @new_dt = ForemanDatacenter::DeviceType.find_by_model("tobedeleted_test")
+        delete :destroy, params: { id: @new_dt.id }, session: set_session_user
+        assert_redirected_to device_types_url
+        assert !ForemanDatacenter::DeviceType.exists?(@new_dt.id)
       end
 
-      def test_edit_submit_button_id
-        get :edit, params: { :id => ForemanDatacenter::DeviceType.first }, session: set_session_user
-        assert_select "[data-id='aid_update_foreman_datacenter_device_type']"
+      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_device_types'
       end
 
-      def test_update_invalid
-        ForemanDatacenter::DeviceType.any_instance.stubs(:valid?).returns(false)
-        put :update, params: { :id => ForemanDatacenter::DeviceType.first.to_param, :device_type => {:model => "3243"} }, session: set_session_user
-        assert_template 'edit'
+      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_device_types'
       end
 
-      def test_update_valid
-        ForemanDatacenter::DeviceType.any_instance.stubs(:valid?).returns(true)
-        put :update, params: { :id => ForemanDatacenter::DeviceType.first.to_param, :device_type => {:model => ForemanDatacenter::DeviceType.first.model} }, session: set_session_user
-        # assert_redirected_to device_type_url(ForemanDatacenter::DeviceType.first)
+      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_device_types'
       end
 
-      def test_destroy
-        device_type = ForemanDatacenter::DeviceType.first
-        # architecture.hosts.delete_all
-        # architecture.hostgroups.delete_all
-        delete :destroy, params: { :id => device_type.id }, session: set_session_user
-        assert_redirected_to device_types_url
-        assert !ForemanDatacenter::DeviceType.exists?(device_type.id)
+      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_device_types'
       end
 
-      def setup_user
+     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_device_type_is_not_found" do
+        get :show, params: { id: 'no.such.device.type' }, session: set_session_user
+        assert_response :not_found
+        assert_template 'common/404'
       end
 
-      def get_factory_name
-        :device_type
+      test "should_not_destroy_device_type_when_not_permitted" do
+        setup_user
+        assert_difference('ForemanDatacenter::DeviceType.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 model" do
+        get :index, params: {:search => "model=\"DeviceType_1NONE\""}, session: set_session_user
+        assert_response :success
+        refute_empty assigns(:device_types)
+        assert assigns(:device_types).include?(device_types(:one))
+      end
+
+      test "should search by manufacturer" do
+        get :index, params: {:search => "manufacturer=\"manufacturer_1\""}, session: set_session_user
+        assert_response :success
+        refute_empty assigns(:device_types)
+        assert assigns(:device_types).include?(device_types(:one))
+      end
+
+      test "should search by subdevice role" do
+        get :index, params: {:search => "subdevice_role=\"None\""}, session: set_session_user
+        assert_response :success
+        refute_empty assigns(:device_types)
+        assert assigns(:device_types).include?(device_types(:one))
+      end
+
+      test "should search by U height" do
+        get :index, params: {:search => "u_height=\"1\""}, session: set_session_user
+        assert_response :success
+        refute_empty assigns(:device_types)
+        assert assigns(:device_types).include?(device_types(:one))
       end
     end
   end

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