SoundSoftware Code Site

# Redmine - project management software

# Copyright (C) 2006-2011  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 'net/imap'

module Redmine

  module IMAP

    class << self

      def check(imap_options={}, options={})

        host = imap_options[:host] || '127.0.0.1'

        port = imap_options[:port] || '143'

        ssl = !imap_options[:ssl].nil?

        folder = imap_options[:folder] || 'INBOX'

        imap = Net::IMAP.new(host, port, ssl)

        imap.login(imap_options[:username], imap_options[:password]) unless imap_options[:username].nil?

        imap.select(folder)

        imap.search(['NOT', 'SEEN']).each do |message_id|

          msg = imap.fetch(message_id,'RFC822')[0].attr['RFC822']

          logger.debug "Receiving message #{message_id}" if logger && logger.debug?

          if MailHandler.receive(msg, options)

            logger.debug "Message #{message_id} successfully received" if logger && logger.debug?

            if imap_options[:move_on_success]

              imap.copy(message_id, imap_options[:move_on_success])

            end

            imap.store(message_id, "+FLAGS", [:Seen, :Deleted])

          else

            logger.debug "Message #{message_id} can not be processed" if logger && logger.debug?

            imap.store(message_id, "+FLAGS", [:Seen])

            if imap_options[:move_on_failure]

              imap.copy(message_id, imap_options[:move_on_failure])

              imap.store(message_id, "+FLAGS", [:Deleted])

            end

          end

        end

        imap.expunge

      end

      private

      def logger

        RAILS_DEFAULT_LOGGER

      end

    end

  end

end

module CodeRay

  # = Duo

  #

  # A Duo is a convenient way to use CodeRay. You just create a Duo,

  # giving it a lang (language of the input code) and a format (desired

  # output format), and call Duo#highlight with the code.

  # 

  # Duo makes it easy to re-use both scanner and encoder for a repetitive

  # task. It also provides a very easy interface syntax:

  # 

  #   require 'coderay'

  #   CodeRay::Duo[:python, :div].highlight 'import this'

  # 

  # Until you want to do uncommon things with CodeRay, I recommend to use

  # this method, since it takes care of everything.

  class Duo

    attr_accessor :lang, :format, :options

    # Create a new Duo, holding a lang and a format to highlight code.

    # 

    # simple:

    #   CodeRay::Duo[:ruby, :html].highlight 'bla 42'

    # 

    # with options:

    #   CodeRay::Duo[:ruby, :html, :hint => :debug].highlight '????::??'

    # 

    # alternative syntax without options:

    #   CodeRay::Duo[:ruby => :statistic].encode 'class << self; end'

    # 

    # alternative syntax with options:

    #   CodeRay::Duo[{ :ruby => :statistic }, :do => :something].encode 'abc'

    # 

    # The options are forwarded to scanner and encoder

    # (see CodeRay.get_scanner_options).

    def initialize lang = nil, format = nil, options = {}

      if format.nil? && lang.is_a?(Hash) && lang.size == 1

        @lang = lang.keys.first

        @format = lang[@lang]

      else

        @lang = lang

        @format = format

      end

      @options = options

    end

    class << self

      # To allow calls like Duo[:ruby, :html].highlight.

      alias [] new

    end

    # The scanner of the duo. Only created once.

    def scanner

      @scanner ||= CodeRay.scanner @lang, CodeRay.get_scanner_options(@options)

    end

    # The encoder of the duo. Only created once.

    def encoder

      @encoder ||= CodeRay.encoder @format, @options

    end

    # Tokenize and highlight the code using +scanner+ and +encoder+.

    def encode code, options = {}

      options = @options.merge options

      encoder.encode(code, @lang, options)

    end

    alias highlight encode

    # Allows to use Duo like a proc object:

    # 

    #  CodeRay::Duo[:python => :yaml].call(code)

    # 

    # or, in Ruby 1.9 and later:

    # 

    #  CodeRay::Duo[:python => :yaml].(code)

    alias call encode

  end

end

// ** I18N

// Calendar EN language

// Author: Mihai Bazon, <mihai_bazon@yahoo.com>

// Encoding: any

// Translater: Mads N. Vestergaard <mnv@coolsms.dk>

// Distributed under the same terms as the calendar itself.

// For translators: please use UTF-8 if possible.  We strongly believe that

// Unicode is the answer to a real internationalized world.  Also please

// include your contact information in the header, as can be seen above.

// full day names

Calendar._DN = new Array

("Søndag",

 "Mandag",

 "Tirsdag",

 "Onsdag",

 "Torsdag",

 "Fredag",

 "Lørdag",

 "Søndag");

// Please note that the following array of short day names (and the same goes

// for short month names, _SMN) isn't absolutely necessary.  We give it here

// for exemplification on how one can customize the short day names, but if

// they are simply the first N letters of the full name you can simply say:

//

//   Calendar._SDN_len = N; // short day name length

//   Calendar._SMN_len = N; // short month name length

//

// If N = 3 then this is not needed either since we assume a value of 3 if not

// present, to be compatible with translation files that were written before

// this feature.

// short day names

Calendar._SDN = new Array

("Søn",

 "Man",

 "Tir",

 "Ons",

 "Tor",

 "Fre",

 "Lør",

 "Søn");

// First day of the week. "0" means display Sunday first, "1" means display

// Monday first, etc.

Calendar._FD = 1;

// full month names

Calendar._MN = new Array

("Januar",

 "Februar",

 "Marts",

 "April",

 "Maj",

 "Juni",

 "Juli",

 "August",

 "September",

 "Oktober",

 "November",

 "December");

// short month names

Calendar._SMN = new Array

("Jan",

 "Feb",

 "Mar",

 "Apr",

 "Maj",

 "Jun",

 "Jul",

 "Aug",

 "Sep",

 "Okt",

 "Nov",

 "Dec");

// tooltips

Calendar._TT = {};

Calendar._TT["INFO"] = "Om denne kalender";

Calendar._TT["ABOUT"] =

"DHTML Date/Time Selector\n" +

"(c) dynarch.com 2002-2005 / Author: Mihai Bazon\n" + // don't translate this this ;-)

"For seneste version, besøg: http://www.dynarch.com/projects/calendar/\n" +

"Distribueret under GNU LGPL.  Se http://gnu.org/licenses/lgpl.html for detaljer." +

"\n\n" +

"Dato valg:\n" +

"- Benyt \xab, \xbb tasterne til at vælge år\n" +

"- Benyt " + String.fromCharCode(0x2039) + ", " + String.fromCharCode(0x203a) + " tasterne til at vælge måned\n" +

"- Hold musetasten inde på punkterne for at vælge hurtigere.";

Calendar._TT["ABOUT_TIME"] = "\n\n" +

"Tids valg:\n" +

"- Klik på en af tidsrammerne for at forhøje det\n" +

"- eller Shift-klik for at mindske det\n" +

"- eller klik og træk for hurtigere valg.";

Calendar._TT["PREV_YEAR"] = "Forrige år (hold for menu)";

Calendar._TT["PREV_MONTH"] = "Forrige måned (hold for menu)";

Calendar._TT["GO_TODAY"] = "Gå til dags dato";

Calendar._TT["NEXT_MONTH"] = "Næste måned (hold for menu)";

Calendar._TT["NEXT_YEAR"] = "Næste år (hold for menu)";

Calendar._TT["SEL_DATE"] = "Vælg dato";

Calendar._TT["DRAG_TO_MOVE"] = "Træk for at flytte";

Calendar._TT["PART_TODAY"] = " (dags dato)";

// the following is to inform that "%s" is to be the first day of week

// %s will be replaced with the day name.

Calendar._TT["DAY_FIRST"] = "Vis %s først";

// This may be locale-dependent.  It specifies the week-end days, as an array

// of comma-separated numbers.  The numbers are from 0 to 6: 0 means Sunday, 1

// means Monday, etc.

Calendar._TT["WEEKEND"] = "6,7";

Calendar._TT["CLOSE"] = "Luk";

Calendar._TT["TODAY"] = "I dag";

Calendar._TT["TIME_PART"] = "(Shift-)Klik eller træk for at ændre værdi";

// date formats

Calendar._TT["DEF_DATE_FORMAT"] = "%Y-%m-%d";

Calendar._TT["TT_DATE_FORMAT"] = "%a, %b %e";

Calendar._TT["WK"] = "uge";

Calendar._TT["TIME"] = "Tid:";

<ul>

  <%= call_hook(:view_issues_context_menu_start, {:issues => @issues, :can => @can, :back => @back }) %>

<% if !@issue.nil? -%>

  <li><%= context_menu_link l(:button_edit), {:controller => 'issues', :action => 'edit', :id => @issue},

          :class => 'icon-edit', :disabled => !@can[:edit] %></li>

<% else %>

  <li><%= context_menu_link l(:button_edit), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id)},

          :class => 'icon-edit', :disabled => !@can[:edit] %></li>

<% end %>

  <% if @allowed_statuses.present? %>

  <li class="folder">

    <a href="#" class="submenu" onclick="return false;"><%= l(:field_status) %></a>

    <ul>

    <% @statuses.each do |s| -%>

        <li><%= context_menu_link h(s.name), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id), :issue => {:status_id => s}, :back_url => @back}, :method => :post,

                                  :selected => (@issue && s == @issue.status), :disabled => !(@can[:update] && @allowed_statuses.include?(s)) %></li>

    <% end -%>

    </ul>

  </li>

  <% end %>

  <% unless @trackers.nil? %>

  <li class="folder">

    <a href="#" class="submenu"><%= l(:field_tracker) %></a>

    <ul>

    <% @trackers.each do |t| -%>

        <li><%= context_menu_link h(t.name), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id), :issue => {'tracker_id' => t}, :back_url => @back}, :method => :post,

                                  :selected => (@issue && t == @issue.tracker), :disabled => !@can[:edit] %></li>

    <% end -%>

    </ul>

  </li>

  <% end %>

  <li class="folder">

    <a href="#" class="submenu"><%= l(:field_priority) %></a>

    <ul>

    <% @priorities.each do |p| -%>

        <li><%= context_menu_link h(p.name), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id), :issue => {'priority_id' => p}, :back_url => @back}, :method => :post,

                                  :selected => (@issue && p == @issue.priority), :disabled => (!@can[:edit] || @issues.detect {|i| !i.leaf?}) %></li>

    <% end -%>

    </ul>

  </li>

  <% #TODO: allow editing versions when multiple projects %>

  <% unless @project.nil? || @project.shared_versions.open.empty? -%>

  <li class="folder">

    <a href="#" class="submenu"><%= l(:field_fixed_version) %></a>

    <ul>

    <% @project.shared_versions.open.sort.each do |v| -%>

        <li><%= context_menu_link format_version_name(v), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id), :issue => {'fixed_version_id' => v}, :back_url => @back}, :method => :post,

                                  :selected => (@issue && v == @issue.fixed_version), :disabled => !@can[:update] %></li>

    <% end -%>

        <li><%= context_menu_link l(:label_none), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id), :issue => {'fixed_version_id' => 'none'}, :back_url => @back}, :method => :post,

                                  :selected => (@issue && @issue.fixed_version.nil?), :disabled => !@can[:update] %></li>

    </ul>

  </li>

  <% end %>

  <% if @assignables.present? -%>

  <li class="folder">

    <a href="#" class="submenu"><%= l(:field_assigned_to) %></a>

    <ul>

    <% @assignables.each do |u| -%>

        <li><%= context_menu_link h(u.name), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id), :issue => {'assigned_to_id' => u}, :back_url => @back}, :method => :post,

                                  :selected => (@issue && u == @issue.assigned_to), :disabled => !@can[:update] %></li>

    <% end -%>

        <li><%= context_menu_link l(:label_nobody), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id), :issue => {'assigned_to_id' => 'none'}, :back_url => @back}, :method => :post,

                                  :selected => (@issue && @issue.assigned_to.nil?), :disabled => !@can[:update] %></li>

    </ul>

  </li>

  <% end %>

  <% unless @project.nil? || @project.issue_categories.empty? -%>

  <li class="folder">

    <a href="#" class="submenu"><%= l(:field_category) %></a>

    <ul>

    <% @project.issue_categories.each do |u| -%>

        <li><%= context_menu_link h(u.name), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id), :issue => {'category_id' => u}, :back_url => @back}, :method => :post,

                                  :selected => (@issue && u == @issue.category), :disabled => !@can[:update] %></li>

    <% end -%>

        <li><%= context_menu_link l(:label_none), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id), :issue => {'category_id' => 'none'}, :back_url => @back}, :method => :post,

                                  :selected => (@issue && @issue.category.nil?), :disabled => !@can[:update] %></li>

    </ul>

  </li>

  <% end -%>

  <% if Issue.use_field_for_done_ratio? %>

  <li class="folder">

    <a href="#" class="submenu"><%= l(:field_done_ratio) %></a>

    <ul>

    <% (0..10).map{|x|x*10}.each do |p| -%>

        <li><%= context_menu_link "#{p}%", {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id), :issue => {'done_ratio' => p}, :back_url => @back}, :method => :post,

                                      :selected => (@issue && p == @issue.done_ratio), :disabled => (!@can[:edit] || @issues.detect {|i| !i.leaf?}) %></li>

    <% end -%>

    </ul>

  </li>

  <% end %>

<% if !@issue.nil? %>

  <% if @can[:log_time] -%>

  <li><%= context_menu_link l(:button_log_time), {:controller => 'timelog', :action => 'new', :issue_id => @issue},

          :class => 'icon-time-add' %></li>

  <% end %>

  <% if User.current.logged? %>

  <li><%= watcher_link(@issue, User.current) %></li>

  <% end %>

<% end %>

<% if @issue.present? %>

  <li><%= context_menu_link l(:button_duplicate), {:controller => 'issues', :action => 'new', :project_id => @project, :copy_from => @issue},

          :class => 'icon-duplicate', :disabled => !@can[:copy] %></li>

<% end %>

  <li><%= context_menu_link l(:button_copy), new_issue_move_path(:ids => @issues.collect(&:id), :copy_options => {:copy => 't'}),

                          :class => 'icon-copy', :disabled => !@can[:move]  %></li>

  <li><%= context_menu_link l(:button_move), new_issue_move_path(:ids => @issues.collect(&:id)),

                          :class => 'icon-move', :disabled => !@can[:move]  %></li>

  <li><%= context_menu_link l(:button_delete), {:controller => 'issues', :action => 'destroy', :ids => @issues.collect(&:id), :back_url => @back},

                            :method => :post, :confirm => issues_destroy_confirmation_message(@issues), :class => 'icon-del', :disabled => !@can[:delete] %></li>

  <%= call_hook(:view_issues_context_menu_end, {:issues => @issues, :can => @can, :back => @back }) %>

</ul>

# Only call Engines.init once, in the after_initialize block so that Rails

# plugin reloading works when turned on

config.after_initialize do

  Engines.init(initializer) if defined? :Engines

end

#!/usr/bin/env ruby

require File.expand_path('../../config/boot',  __FILE__)

require 'commands/generate'

# Redmine - project management software

# Copyright (C) 2006-2011  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::CodesetUtilTest < ActiveSupport::TestCase

  def test_to_utf8_by_setting_from_latin1

    with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do

      s1 = "Texte encod\xc3\xa9"

      s2 = "Texte encod\xe9"

      s3 = s2.dup

      if s1.respond_to?(:force_encoding)

        s1.force_encoding("UTF-8")

        s2.force_encoding("ASCII-8BIT")

        s3.force_encoding("UTF-8")

      end

      assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s2)

      assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s3)

    end

  end

  def test_to_utf8_by_setting_from_euc_jp

    with_settings :repositories_encodings => 'UTF-8,EUC-JP' do

      s1 = "\xe3\x83\xac\xe3\x83\x83\xe3\x83\x89\xe3\x83\x9e\xe3\x82\xa4\xe3\x83\xb3"

      s2 = "\xa5\xec\xa5\xc3\xa5\xc9\xa5\xde\xa5\xa4\xa5\xf3"

      s3 = s2.dup

      if s1.respond_to?(:force_encoding)

        s1.force_encoding("UTF-8")

        s2.force_encoding("ASCII-8BIT")

        s3.force_encoding("UTF-8")

      end

      assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s2)

      assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s3)

    end

  end

  def test_to_utf8_by_setting_should_be_converted_all_latin1

    with_settings :repositories_encodings => 'ISO-8859-1' do

      s1 = "\xc3\x82\xc2\x80"

      s2 = "\xC2\x80"

      s3 = s2.dup

      if s1.respond_to?(:force_encoding)

        s1.force_encoding("UTF-8")

        s2.force_encoding("ASCII-8BIT")

        s3.force_encoding("UTF-8")

      end

      assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s2)

      assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s3)

    end

  end

  def test_to_utf8_by_setting_blank_string

    assert_equal "",  Redmine::CodesetUtil.to_utf8_by_setting("")

    assert_equal nil, Redmine::CodesetUtil.to_utf8_by_setting(nil)

  end

  def test_to_utf8_by_setting_returns_ascii_as_utf8

    s1 = "ASCII"

    s2 = s1.dup

    if s1.respond_to?(:force_encoding)

      s1.force_encoding("UTF-8")

      s2.force_encoding("ISO-8859-1")

    end

    str1 = Redmine::CodesetUtil.to_utf8_by_setting(s1)

    str2 = Redmine::CodesetUtil.to_utf8_by_setting(s2)

    assert_equal s1, str1

    assert_equal s1, str2

    if s1.respond_to?(:force_encoding)

      assert_equal "UTF-8", str1.encoding.to_s

      assert_equal "UTF-8", str2.encoding.to_s

    end

  end

  def test_to_utf8_by_setting_invalid_utf8_sequences_should_be_stripped

    with_settings :repositories_encodings => '' do

      # s1 = File.read("#{RAILS_ROOT}/test/fixtures/encoding/iso-8859-1.txt")

      s1 = "Texte encod\xe9 en ISO-8859-1."

      s1.force_encoding("ASCII-8BIT") if s1.respond_to?(:force_encoding)

      str = Redmine::CodesetUtil.to_utf8_by_setting(s1)

      if str.respond_to?(:force_encoding)

        assert str.valid_encoding?

        assert_equal "UTF-8", str.encoding.to_s

      end

      assert_equal "Texte encod? en ISO-8859-1.", str

    end

  end

  def test_to_utf8_by_setting_invalid_utf8_sequences_should_be_stripped_ja_jis

    with_settings :repositories_encodings => 'ISO-2022-JP' do

      s1 = "test\xb5\xfetest\xb5\xfe"

      s1.force_encoding("ASCII-8BIT") if s1.respond_to?(:force_encoding)

      str = Redmine::CodesetUtil.to_utf8_by_setting(s1)

      if str.respond_to?(:force_encoding)

        assert str.valid_encoding?

        assert_equal "UTF-8", str.encoding.to_s

      end

      assert_equal "test??test??", str

    end

  end

end

--- 

enabled_modules_001: 

  name: issue_tracking

  project_id: 1

  id: 1

enabled_modules_002: 

  name: time_tracking

  project_id: 1

  id: 2

enabled_modules_003: 

  name: news

  project_id: 1

  id: 3

enabled_modules_004: 

  name: documents

  project_id: 1

  id: 4

enabled_modules_005: 

  name: files

  project_id: 1

  id: 5

enabled_modules_006: 

  name: wiki

  project_id: 1

  id: 6

enabled_modules_007: 

  name: repository

  project_id: 1

  id: 7

enabled_modules_008: 

  name: boards

  project_id: 1

  id: 8

enabled_modules_009: 

  name: repository

  project_id: 3

  id: 9

enabled_modules_010: 

  name: wiki

  project_id: 3

  id: 10

enabled_modules_011: 

  name: issue_tracking

  project_id: 2

  id: 11

enabled_modules_012: 

  name: time_tracking

  project_id: 3

  id: 12

enabled_modules_013: 

  name: issue_tracking

  project_id: 3

  id: 13

enabled_modules_014: 

  name: issue_tracking

  project_id: 5

  id: 14

enabled_modules_015: 

  name: wiki

  project_id: 2

  id: 15

enabled_modules_016: 

  name: boards

  project_id: 2

  id: 16

enabled_modules_017: 

  name: calendar

  project_id: 1

  id: 17

enabled_modules_018: 

  name: gantt 

  project_id: 1

  id: 18

enabled_modules_019: 

  name: calendar

  project_id: 2

  id: 19

enabled_modules_020: 

  name: gantt 

  project_id: 2

  id: 20

enabled_modules_021: 

  name: calendar

  project_id: 3

  id: 21

enabled_modules_022: 

  name: gantt

  project_id: 3

  id: 22

enabled_modules_023: 

  name: calendar

  project_id: 5

  id: 23

enabled_modules_024: 

  name: gantt 

  project_id: 5

  id: 24

enabled_modules_025: 

  name: news 

  project_id: 2

  id: 25

#!/usr/bin/env ruby

require File.expand_path('../../config/boot',  __FILE__)

require 'commands/console'

# Tests in this file ensure that:

#

# * plugin controller actions are found

# * actions defined in application controllers take precedence over those in plugins

# * actions in controllers in subsequently loaded plugins take precendence over those in previously loaded plugins

# * this works for actions in namespaced controllers accordingly

require File.dirname(__FILE__) + '/../test_helper'

class ControllerLoadingTest < ActionController::TestCase

  def setup

    @request    = ActionController::TestRequest.new

    @response   = ActionController::TestResponse.new

  end

  # plugin controller actions should be found

	def test_WITH_an_action_defined_only_in_a_plugin_IT_should_use_this_action

	  get_action_on_controller :an_action, :alpha_plugin

    assert_response_body 'rendered in AlphaPluginController#an_action'

  end

	def test_WITH_an_action_defined_only_in_a_namespaced_plugin_controller_IT_should_use_this_action

	  get_action_on_controller :an_action, :alpha_plugin, :namespace

    assert_response_body 'rendered in Namespace::AlphaPluginController#an_action'

  end

  # app takes precedence over plugins

  def test_WITH_an_action_defined_in_both_app_and_plugin_IT_should_use_the_one_in_app

	  get_action_on_controller :an_action, :app_and_plugin

    assert_response_body 'rendered in AppAndPluginController#an_action (from app)'

  end

  def test_WITH_an_action_defined_in_namespaced_controllers_in_both_app_and_plugin_IT_should_use_the_one_in_app

	  get_action_on_controller :an_action, :app_and_plugin, :namespace

    assert_response_body 'rendered in Namespace::AppAndPluginController#an_action (from app)'

  end

  # subsequently loaded plugins take precendence over previously loaded plugins

  def test_WITH_an_action_defined_in_two_plugin_controllers_IT_should_use_the_latter_of_both

	  get_action_on_controller :an_action, :shared_plugin

    assert_response_body 'rendered in SharedPluginController#an_action (from beta_plugin)'

  end

  def test_WITH_an_action_defined_in_two_namespaced_plugin_controllers_IT_should_use_the_latter_of_both

	  get_action_on_controller :an_action, :shared_plugin, :namespace

    assert_response_body 'rendered in Namespace::SharedPluginController#an_action (from beta_plugin)'

  end

end