foreman_datacenter 1.23.0 → 1.24.3

data/app/views/foreman_datacenter/racks/show.html.erb

@@ -1,5 +1,6 @@
 <% stylesheet 'foreman_datacenter/device_roles' %>
 <% stylesheet 'foreman_datacenter/datacenter' %>
+<% stylesheet 'foreman_datacenter/rack_show' %>
 <% stylesheet 'foreman_datacenter/modal' %>
 <% javascript 'foreman_datacenter/modal' %>
 
@@ -89,10 +90,11 @@
   </div>
 
   <div class="col-md-6">
-    <!-- Devices -->
-    <%= render "device_position", rack: @rack %>
-    <!-- Unpositioned Devices -->
-    <%= render "unpositioned_devices", rack: @rack if @rack.unpositioned_devices.count != 0 %>
+    <%= render "device_position_new", rack: @rack %>
+      <!-- Devices -->
+      <%#= render "device_position", rack: @rack %>
+      <!-- Unpositioned Devices -->
+      <%#= render "unpositioned_devices", rack: @rack if @rack.unpositioned_devices.count != 0 %>
     <div><h6 class="text-right"><%= _("* side is not defined") %></h6></div>
     <div><h6 class="text-right"><%= _("** size is not defined") %></h6></div>
   </div>

data/config/routes.rb

@@ -74,11 +74,30 @@ Foreman::Application.routes.draw do
   get 'datacenter/import_to_device', to: 'hosts#import_to_device',
       as: 'import_to_device'
 
-  get '/api/:controller/(:action(/*welcome))'
+  # get '/api/:controller/(:action(/*welcome))'
   # get '/datacenter/(:controller)/help', :action => 'welcome', :as => "help"
 
   scope 'datacenter', module: :foreman_datacenter do
 
+    welcoming_controllers = [
+      'console_ports',
+      'device_interface_connections',
+      'device_interface_connections',
+      'device_roles',
+      'device_types',
+      'devices',
+      'manufacturers',
+      'platforms',
+      'power_ports',
+      'rack_groups',
+      'racks',
+      'sites',
+    ]
+
+    welcoming_controllers.each do |welcoming_controller|
+      get "#{welcoming_controller}/help", :action => :welcome, :controller => welcoming_controller
+    end
+
     post :site_update_associated_objects, to: "sites#update_associated_objects"
     post :rack_group_update_associated_objects, to: "rack_groups#update_associated_objects"
     post :rack_update_associated_objects, to: "racks#update_associated_objects"
@@ -94,6 +113,7 @@ Foreman::Application.routes.draw do
     end
     resources :racks do
       member do
+        get :export_to_csv
         get :move
       end
       collection do

data/lib/foreman_datacenter/version.rb

@@ -1,3 +1,3 @@
 module ForemanDatacenter
-  VERSION = '1.23.0'.freeze
+  VERSION = '1.24.3'.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