jro_apps/redmine Commit - r13383:64fea07affaf

Support for named route in project menu and a new :permission option (#6426)....

Jean-Philippe Lang -

r13383:64fea07affaf

parent child

Context file:

r13383:64fea07affaf

Collapse all files

lib/redmine/menu_manager.rb +20 -6

             # Redmine - project management software
             # Copyright (C) 2006-2014  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module Redmine
               module MenuManager
                 class MenuError < StandardError #:nodoc:
                 end
                 module MenuController
                   def self.included(base)
                     base.extend(ClassMethods)
                   end
                   module ClassMethods
                     @@menu_items = Hash.new {|hash, key| hash[key] = {:default => key, :actions => {}}}
                     mattr_accessor :menu_items
                     # Set the menu item name for a controller or specific actions
                     # Examples:
                     #   * menu_item :tickets # => sets the menu name to :tickets for the whole controller
                     #   * menu_item :tickets, :only => :list # => sets the menu name to :tickets for the 'list' action only
                     #   * menu_item :tickets, :only => [:list, :show] # => sets the menu name to :tickets for 2 actions only
                     #
                     # The default menu item name for a controller is controller_name by default
                     # Eg. the default menu item name for ProjectsController is :projects
                     def menu_item(id, options = {})
                       if actions = options[:only]
                         actions = [] << actions unless actions.is_a?(Array)
                         actions.each {|a| menu_items[controller_name.to_sym][:actions][a.to_sym] = id}
                       else
                         menu_items[controller_name.to_sym][:default] = id
                       end
                     end
                   end
                   def menu_items
                     self.class.menu_items
                   end
                   # Returns the menu item name according to the current action
                   def current_menu_item
                     @current_menu_item ||= menu_items[controller_name.to_sym][:actions][action_name.to_sym] ||
                                              menu_items[controller_name.to_sym][:default]
                   end
                   # Redirects user to the menu item of the given project
                   # Returns false if user is not authorized
                   def redirect_to_project_menu_item(project, name)
                     item = Redmine::MenuManager.items(:project_menu).detect {|i| i.name.to_s == name.to_s}
                     if item && item.allowed?(User.current, project)
                       redirect_to({item.param => project}.merge(item.url))
                       return true
                     end
                     false
                   end
                 end
                 module MenuHelper
                   # Returns the current menu item name
                   def current_menu_item
                     controller.current_menu_item
                   end
                   # Renders the application main menu
                   def render_main_menu(project)
                     render_menu((project && !project.new_record?) ? :project_menu : :application_menu, project)
                   end
                   def display_main_menu?(project)
                     menu_name = project && !project.new_record? ? :project_menu : :application_menu
                     Redmine::MenuManager.items(menu_name).children.present?
                   end
                   def render_menu(menu, project=nil)
                     links = []
                     menu_items_for(menu, project) do |node|
                       links << render_menu_node(node, project)
                     end
                     links.empty? ? nil : content_tag('ul', links.join("\n").html_safe)
                   end
                   def render_menu_node(node, project=nil)
                     if node.children.present? || !node.child_menus.nil?
                       return render_menu_node_with_children(node, project)
                     else
                       caption, url, selected = extract_node_details(node, project)
                       return content_tag('li',
                                            render_single_menu_node(node, caption, url, selected))
                     end
                   end
                   def render_menu_node_with_children(node, project=nil)
                     caption, url, selected = extract_node_details(node, project)
                     html = [].tap do |html|
                       html << '<li>'
                       # Parent
                       html << render_single_menu_node(node, caption, url, selected)
                       # Standard children
                       standard_children_list = "".html_safe.tap do |child_html|
                         node.children.each do |child|
                           child_html << render_menu_node(child, project)
                         end
                       end
                       html << content_tag(:ul, standard_children_list, :class => 'menu-children') unless standard_children_list.empty?
                       # Unattached children
                       unattached_children_list = render_unattached_children_menu(node, project)
                       html << content_tag(:ul, unattached_children_list, :class => 'menu-children unattached') unless unattached_children_list.blank?
                       html << '</li>'
                     end
                     return html.join("\n").html_safe
                   end
                   # Returns a list of unattached children menu items
                   def render_unattached_children_menu(node, project)
                     return nil unless node.child_menus
                     "".html_safe.tap do |child_html|
                       unattached_children = node.child_menus.call(project)
                       # Tree nodes support #each so we need to do object detection
                       if unattached_children.is_a? Array
                         unattached_children.each do |child|
                           child_html << content_tag(:li, render_unattached_menu_item(child, project))
                         end
                       else
                         raise MenuError, ":child_menus must be an array of MenuItems"
                       end
                     end
                   end
                   def render_single_menu_node(item, caption, url, selected)
                     link_to(h(caption), url, item.html_options(:selected => selected))
                   end
                   def render_unattached_menu_item(menu_item, project)
                     raise MenuError, ":child_menus must be an array of MenuItems" unless menu_item.is_a? MenuItem
                     if menu_item.allowed?(User.current, project)
                       link_to(menu_item.caption, menu_item.url, menu_item.html_options)
                     end
                   end
                   def menu_items_for(menu, project=nil)
                     items = []
                     Redmine::MenuManager.items(menu).root.children.each do |node|
                       if node.allowed?(User.current, project)
                         if block_given?
                           yield node
                         else
                           items << node  # TODO: not used?
                         end
                       end
                     end
                     return block_given? ? nil : items
                   end
                   def extract_node_details(node, project=nil)
                     item = node
                     url = case item.url
                     when Hash
                       project.nil? ? item.url : {item.param => project}.merge(item.url)
                     when Symbol
-                      send(item.url)
+                      if project
+                        send(item.url, project)
+                      else
+                        send(item.url)
+                      end
                     else
                       item.url
                     end
                     caption = item.caption(project)
                     return [caption, url, (current_menu_item == item.name)]
                   end
                   # See MenuItem#allowed?
                   def allowed_node?(node, user, project)
                     node.allowed?(user, project)
                   end
                 end
                 class << self
                   def map(menu_name)
                     @items ||= {}
                     mapper = Mapper.new(menu_name.to_sym, @items)
                     if block_given?
                       yield mapper
                     else
                       mapper
                     end
                   end
                   def items(menu_name)
                     @items[menu_name.to_sym] || MenuNode.new(:root, {})
                   end
                 end
                 class Mapper
                   attr_reader :menu, :menu_items
                   def initialize(menu, items)
                     items[menu] ||= MenuNode.new(:root, {})
                     @menu = menu
                     @menu_items = items[menu]
                   end
                   # Adds an item at the end of the menu. Available options:
                   # * param: the parameter name that is used for the project id (default is :id)
                   # * if: a Proc that is called before rendering the item, the item is displayed only if it returns true
                   # * caption that can be:
                   #   * a localized string Symbol
                   #   * a String
                   #   * a Proc that can take the project as argument
                   # * before, after: specify where the menu item should be inserted (eg. :after => :activity)
                   # * parent: menu item will be added as a child of another named menu (eg. :parent => :issues)
                   # * children: a Proc that is called before rendering the item. The Proc should return an array of MenuItems, which will be added as children to this item.
                   #   eg. :children => Proc.new {|project| [Redmine::MenuManager::MenuItem.new(...)] }
                   # * last: menu item will stay at the end (eg. :last => true)
                   # * html_options: a hash of html options that are passed to link_to
                   def push(name, url, options={})
                     options = options.dup
                     if options[:parent]
                       subtree = self.find(options[:parent])
                       if subtree
                         target_root = subtree
                       else
                         target_root = @menu_items.root
                       end
                     else
                       target_root = @menu_items.root
                     end
                     # menu item position
                     if first = options.delete(:first)
                       target_root.prepend(MenuItem.new(name, url, options))
                     elsif before = options.delete(:before)
                       if exists?(before)
                         target_root.add_at(MenuItem.new(name, url, options), position_of(before))
                       else
                         target_root.add(MenuItem.new(name, url, options))
                       end
                     elsif after = options.delete(:after)
                       if exists?(after)
                         target_root.add_at(MenuItem.new(name, url, options), position_of(after) + 1)
                       else
                         target_root.add(MenuItem.new(name, url, options))
                       end
                     elsif options[:last] # don't delete, needs to be stored
                       target_root.add_last(MenuItem.new(name, url, options))
                     else
                       target_root.add(MenuItem.new(name, url, options))
                     end
                   end
                   # Removes a menu item
                   def delete(name)
                     if found = self.find(name)
                       @menu_items.remove!(found)
                     end
                   end
                   # Checks if a menu item exists
                   def exists?(name)
                     @menu_items.any? {|node| node.name == name}
                   end
                   def find(name)
                     @menu_items.find {|node| node.name == name}
                   end
                   def position_of(name)
                     @menu_items.each do |node|
                       if node.name == name
                         return node.position
                       end
                     end
                   end
                 end
                 class MenuNode
                   include Enumerable
                   attr_accessor :parent
                   attr_reader :last_items_count, :name
                   def initialize(name, content = nil)
                     @name = name
                     @children = []
                     @last_items_count = 0
                   end
                   def children
                     if block_given?
                       @children.each {|child| yield child}
                     else
                       @children
                     end
                   end
                   # Returns the number of descendants + 1
                   def size
                     @children.inject(1) {|sum, node| sum + node.size}
                   end
                   def each &block
                     yield self
                     children { |child| child.each(&block) }
                   end
                   # Adds a child at first position
                   def prepend(child)
                     add_at(child, 0)
                   end
                   # Adds a child at given position
                   def add_at(child, position)
                     raise "Child already added" if find {|node| node.name == child.name}
                     @children = @children.insert(position, child)
                     child.parent = self
                     child
                   end
                   # Adds a child as last child
                   def add_last(child)
                     add_at(child, -1)
                     @last_items_count += 1
                     child
                   end
                   # Adds a child
                   def add(child)
                     position = @children.size - @last_items_count
                     add_at(child, position)
                   end
                   alias :<< :add
                   # Removes a child
                   def remove!(child)
                     @children.delete(child)
                     @last_items_count -= +1 if child && child.last
                     child.parent = nil
                     child
                   end
                   # Returns the position for this node in it's parent
                   def position
                     self.parent.children.index(self)
                   end
                   # Returns the root for this node
                   def root
                     root = self
                     root = root.parent while root.parent
                     root
                   end
                 end
                 class MenuItem < MenuNode
                   include Redmine::I18n
-                  attr_reader :name, :url, :param, :condition, :parent, :child_menus, :last
+                  attr_reader :name, :url, :param, :condition, :parent, :child_menus, :last, :permission
-                  def initialize(name, url, options)
+                  def initialize(name, url, options={})
                     raise ArgumentError, "Invalid option :if for menu item '#{name}'" if options[:if] && !options[:if].respond_to?(:call)
                     raise ArgumentError, "Invalid option :html for menu item '#{name}'" if options[:html] && !options[:html].is_a?(Hash)
                     raise ArgumentError, "Cannot set the :parent to be the same as this item" if options[:parent] == name.to_sym
                     raise ArgumentError, "Invalid option :children for menu item '#{name}'" if options[:children] && !options[:children].respond_to?(:call)
                     @name = name
                     @url = url
                     @condition = options[:if]
+                    @permission = options[:permission]
+                    @permission ||= false if options.key?(:permission)
                     @param = options[:param] || :id
                     @caption = options[:caption]
                     @html_options = options[:html] || {}
                     # Adds a unique class to each menu item based on its name
                     @html_options[:class] = [@html_options[:class], @name.to_s.dasherize].compact.join(' ')
                     @parent = options[:parent]
                     @child_menus = options[:children]
                     @last = options[:last] || false
                     super @name.to_sym
                   end
                   def caption(project=nil)
                     if @caption.is_a?(Proc)
                       c = @caption.call(project).to_s
                       c = @name.to_s.humanize if c.blank?
                       c
                     else
                       if @caption.nil?
                         l_or_humanize(name, :prefix => 'label_')
                       else
                         @caption.is_a?(Symbol) ? l(@caption) : @caption
                       end
                     end
                   end
                   def html_options(options={})
                     if options[:selected]
                       o = @html_options.dup
                       o[:class] += ' selected'
                       o
                     else
                       @html_options
                     end
                   end
                   # Checks if a user is allowed to access the menu item by:
                   #
-                  # * Checking the url target (project only)
+                  # * Checking the permission or the url target (project only)
                   # * Checking the conditions of the item
                   def allowed?(user, project)
-                    if url.is_a?(Hash) && project && user && !user.allowed_to?(url, project)
+                    if user && project
-                      return false
+                      if permission
+                        unless user.allowed_to?(permission, project)
+                          return false
+                        end
+                      elsif permission.nil? && url.is_a?(Hash)
+                        unless user.allowed_to?(url, project)
+                          return false
+                        end
+                      end
                     end
                     if condition && !condition.call(project)
                       # Condition that doesn't pass
                       return false
                     end
                     return true
                   end
                 end
               end
             end

test/unit/lib/redmine/menu_manager/menu_helper_test.rb +27 0

             # Redmine - project management software
             # Copyright (C) 2006-2014  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../../../test_helper', __FILE__)
             class Redmine::MenuManager::MenuHelperTest < ActionView::TestCase
               include Redmine::MenuManager::MenuHelper
               include ERB::Util
               fixtures :users, :members, :projects, :enabled_modules, :roles, :member_roles
               def setup
                 setup_with_controller
                 # Stub the current menu item in the controller
                 def current_menu_item
                   :index
                 end
               end
               def test_render_single_menu_node
                 node = Redmine::MenuManager::MenuItem.new(:testing, '/test', { })
                 @output_buffer = render_single_menu_node(node, 'This is a test', node.url, false)
                 assert_select("a.testing", "This is a test")
               end
               def test_render_menu_node
                 single_node = Redmine::MenuManager::MenuItem.new(:single_node, '/test', { })
                 @output_buffer = render_menu_node(single_node, nil)
                 assert_select("li") do
                   assert_select("a.single-node", "Single node")
                 end
               end
+              def test_render_menu_node_with_symbol_as_url
+                node = Redmine::MenuManager::MenuItem.new(:testing, :issues_path)
+                @output_buffer = render_menu_node(node, nil)
+                assert_select "a[href=/issues]", "Testing"
+              end
+              def test_render_menu_node_with_symbol_as_url_and_project
+                node = Redmine::MenuManager::MenuItem.new(:testing, :project_issues_path)
+                @output_buffer = render_menu_node(node, Project.find(1))
+                assert_select "a[href=/projects/ecookbook/issues]", "Testing"
+              end
               def test_render_menu_node_with_nested_items
                 parent_node = Redmine::MenuManager::MenuItem.new(:parent_node, '/test', { })
                 parent_node << Redmine::MenuManager::MenuItem.new(:child_one_node, '/test', { })
                 parent_node << Redmine::MenuManager::MenuItem.new(:child_two_node, '/test', { })
                 parent_node <<
                   Redmine::MenuManager::MenuItem.new(:child_three_node, '/test', { }) <<
                   Redmine::MenuManager::MenuItem.new(:child_three_inner_node, '/test', { })
                 @output_buffer = render_menu_node(parent_node, nil)
                 assert_select("li") do
                   assert_select("a.parent-node", "Parent node")
                   assert_select("ul") do
                     assert_select("li a.child-one-node", "Child one node")
                     assert_select("li a.child-two-node", "Child two node")
                     assert_select("li") do
                       assert_select("a.child-three-node", "Child three node")
                       assert_select("ul") do
                         assert_select("li a.child-three-inner-node", "Child three inner node")
                       end
                     end
                   end
                 end
               end
               def test_render_menu_node_with_children
                 User.current = User.find(2)
                 parent_node = Redmine::MenuManager::MenuItem.new(:parent_node,
                                                                  '/test',
                                                                  {
                                                                    :children => Proc.new {|p|
                                                                      children = []
 .times do |time|
                                                                        children << Redmine::MenuManager::MenuItem.new("test_child_#{time}",
                                                                                                                          {:controller => 'issues', :action => 'index'},
                                                                                                                          {})
                                                                      end
                                                                      children
                                                                    }
                                                                  })
                 @output_buffer = render_menu_node(parent_node, Project.find(1))
                 assert_select("li") do
                   assert_select("a.parent-node", "Parent node")
                   assert_select("ul") do
                     assert_select("li a.test-child-0", "Test child 0")
                     assert_select("li a.test-child-1", "Test child 1")
                     assert_select("li a.test-child-2", "Test child 2")
                   end
                 end
               end
               def test_render_menu_node_with_nested_items_and_children
                 User.current = User.find(2)
                 parent_node = Redmine::MenuManager::MenuItem.new(:parent_node,
                                                                  '/test',
                                                                  {
                                                                    :children => Proc.new {|p|
                                                                      children = []
 .times do |time|
                                                                        children << Redmine::MenuManager::MenuItem.new("test_child_#{time}", {:controller => 'issues', :action => 'index'}, {})
                                                                      end
                                                                      children
                                                                    }
                                                                  })
                 parent_node << Redmine::MenuManager::MenuItem.new(:child_node,
                                                                  '/test',
                                                                  {
                                                                    :children => Proc.new {|p|
                                                                      children = []
 .times do |time|
                                                                         children << Redmine::MenuManager::MenuItem.new("test_dynamic_child_#{time}", {:controller => 'issues', :action => 'index'}, {})
                                                                      end
                                                                      children
                                                                    }
                                                                  })
                 @output_buffer = render_menu_node(parent_node, Project.find(1))
                 assert_select("li") do
                   assert_select("a.parent-node", "Parent node")
                   assert_select("ul") do
                     assert_select("li a.child-node", "Child node")
                     assert_select("ul") do
                       assert_select("li a.test-dynamic-child-0", "Test dynamic child 0")
                       assert_select("li a.test-dynamic-child-1", "Test dynamic child 1")
                       assert_select("li a.test-dynamic-child-2", "Test dynamic child 2")
                       assert_select("li a.test-dynamic-child-3", "Test dynamic child 3")
                       assert_select("li a.test-dynamic-child-4", "Test dynamic child 4")
                       assert_select("li a.test-dynamic-child-5", "Test dynamic child 5")
                     end
                     assert_select("li a.test-child-0", "Test child 0")
                     assert_select("li a.test-child-1", "Test child 1")
                     assert_select("li a.test-child-2", "Test child 2")
                   end
                 end
               end
               def test_render_menu_node_with_children_without_an_array
                 parent_node = Redmine::MenuManager::MenuItem.new(:parent_node,
                                                                  '/test',
                                                                  {
                                                                    :children => Proc.new {|p| Redmine::MenuManager::MenuItem.new("test_child", "/testing", {})}
                                                                  })
                 assert_raises Redmine::MenuManager::MenuError, ":children must be an array of MenuItems" do
                   @output_buffer = render_menu_node(parent_node, Project.find(1))
                 end
               end
               def test_render_menu_node_with_incorrect_children
                 parent_node = Redmine::MenuManager::MenuItem.new(:parent_node,
                                                                  '/test',
                                                                  {
                                                                    :children => Proc.new {|p| ["a string"] }
                                                                  })
                 assert_raises Redmine::MenuManager::MenuError, ":children must be an array of MenuItems" do
                   @output_buffer = render_menu_node(parent_node, Project.find(1))
                 end
               end
               def test_menu_items_for_should_yield_all_items_if_passed_a_block
                 menu_name = :test_menu_items_for_should_yield_all_items_if_passed_a_block
                 Redmine::MenuManager.map menu_name do |menu|
                   menu.push(:a_menu, '/', { })
                   menu.push(:a_menu_2, '/', { })
                   menu.push(:a_menu_3, '/', { })
                 end
                 items_yielded = []
                 menu_items_for(menu_name) do |item|
                   items_yielded << item
                 end
                 assert_equal 3, items_yielded.size
               end
               def test_menu_items_for_should_return_all_items
                 menu_name = :test_menu_items_for_should_return_all_items
                 Redmine::MenuManager.map menu_name do |menu|
                   menu.push(:a_menu, '/', { })
                   menu.push(:a_menu_2, '/', { })
                   menu.push(:a_menu_3, '/', { })
                 end
                 items = menu_items_for(menu_name)
                 assert_equal 3, items.size
               end
               def test_menu_items_for_should_skip_unallowed_items_on_a_project
                 menu_name = :test_menu_items_for_should_skip_unallowed_items_on_a_project
                 Redmine::MenuManager.map menu_name do |menu|
                   menu.push(:a_menu, {:controller => 'issues', :action => 'index' }, { })
                   menu.push(:a_menu_2, {:controller => 'issues', :action => 'index' }, { })
                   menu.push(:unallowed, {:controller => 'issues', :action => 'unallowed' }, { })
                 end
                 User.current = User.find(2)
                 items = menu_items_for(menu_name, Project.find(1))
                 assert_equal 2, items.size
               end
+              def test_menu_items_for_should_skip_items_that_fail_the_permission
+                menu_name = :test_menu_items_for_should_skip_items_that_fail_the_permission
+                Redmine::MenuManager.map menu_name do |menu|
+                  menu.push(:a_menu, :project_issues_path)
+                  menu.push(:unallowed, :project_issues_path, :permission => :unallowed)
+                end
+                User.current = User.find(2)
+                items = menu_items_for(menu_name, Project.find(1))
+                assert_equal 1, items.size
+              end
               def test_menu_items_for_should_skip_items_that_fail_the_conditions
                 menu_name = :test_menu_items_for_should_skip_items_that_fail_the_conditions
                 Redmine::MenuManager.map menu_name do |menu|
                   menu.push(:a_menu, {:controller => 'issues', :action => 'index' }, { })
                   menu.push(:unallowed,
                             {:controller => 'issues', :action => 'index' },
                             { :if => Proc.new { false }})
                 end
                 User.current = User.find(2)
                 items = menu_items_for(menu_name, Project.find(1))
                 assert_equal 1, items.size
               end
             end

test/unit/lib/redmine/menu_manager/menu_item_test.rb 0 -6

             # Redmine - project management software
             # Copyright (C) 2006-2009  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../../../test_helper', __FILE__)
             module RedmineMenuTestHelper
               # Helpers
               def get_menu_item(menu_name, item_name)
                 Redmine::MenuManager.items(menu_name).find {|item| item.name == item_name.to_sym}
               end
             end
             class Redmine::MenuManager::MenuItemTest < ActiveSupport::TestCase
               include RedmineMenuTestHelper
               Redmine::MenuManager.map :test_menu do |menu|
                 menu.push(:parent, '/test', { })
                 menu.push(:child_menu, '/test', { :parent => :parent})
                 menu.push(:child2_menu, '/test', { :parent => :parent})
               end
               # context new menu item
               def test_new_menu_item_should_require_a_name
                 assert_raises ArgumentError do
                   Redmine::MenuManager::MenuItem.new
                 end
               end
               def test_new_menu_item_should_require_an_url
                 assert_raises ArgumentError do
                   Redmine::MenuManager::MenuItem.new(:test_missing_url)
                 end
               end
-              def test_new_menu_item_should_require_the_options
-                assert_raises ArgumentError do
-                  Redmine::MenuManager::MenuItem.new(:test_missing_options, '/test')
-                end
-              end
               def test_new_menu_item_with_all_required_parameters
                 assert Redmine::MenuManager::MenuItem.new(:test_good_menu, '/test', {})
               end
               def test_new_menu_item_should_require_a_proc_to_use_for_the_if_condition
                 assert_raises ArgumentError do
                   Redmine::MenuManager::MenuItem.new(:test_error, '/test',
                                                      {
                                                        :if => ['not_a_proc']
                                                      })
                 end
                 assert Redmine::MenuManager::MenuItem.new(:test_good_if, '/test',
                                                           {
                                                             :if => Proc.new{}
                                                           })
               end
               def test_new_menu_item_should_allow_a_hash_for_extra_html_options
                 assert_raises ArgumentError do
                   Redmine::MenuManager::MenuItem.new(:test_error, '/test',
                                                      {
                                                        :html => ['not_a_hash']
                                                      })
                 end
                 assert Redmine::MenuManager::MenuItem.new(:test_good_html, '/test',
                                                           {
                                                             :html => { :onclick => 'doSomething'}
                                                           })
               end
               def test_new_menu_item_should_require_a_proc_to_use_the_children_option
                 assert_raises ArgumentError do
                   Redmine::MenuManager::MenuItem.new(:test_error, '/test',
                                                      {
                                                        :children => ['not_a_proc']
                                                      })
                 end
                 assert Redmine::MenuManager::MenuItem.new(:test_good_children, '/test',
                                                           {
                                                             :children => Proc.new{}
                                                           })
               end
               def test_new_should_not_allow_setting_the_parent_item_to_the_current_item
                 assert_raises ArgumentError do
                   Redmine::MenuManager::MenuItem.new(:test_error, '/test', { :parent => :test_error })
                 end
               end
               def test_has_children
                 parent_item = get_menu_item(:test_menu, :parent)
                 assert parent_item.children.present?
                 assert_equal 2, parent_item.children.size
                 assert_equal get_menu_item(:test_menu, :child_menu), parent_item.children[0]
                 assert_equal get_menu_item(:test_menu, :child2_menu), parent_item.children[1]
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages