SoundSoftware Code Site

class AddCommitAccessPermission < ActiveRecord::Migration

  def self.up

    Role.all.select { |r| not r.builtin? }.each do |r|

      r.add_permission!(:commit_access)

    end

  end

  def self.down

    Role.all.select { |r| not r.builtin? }.each do |r|

      r.remove_permission!(:commit_access)

    end

  end

end

# Redmine - project management software

# Copyright (C) 2006-2013  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.

# Generic exception for when the AuthSource can not be reached

# (eg. can not connect to the LDAP)

class AuthSourceException < Exception; end

class AuthSourceTimeoutException < AuthSourceException; end

class AuthSource < ActiveRecord::Base

  include Redmine::SubclassFactory

  include Redmine::Ciphering

  has_many :users

  validates_presence_of :name

  validates_uniqueness_of :name

  validates_length_of :name, :maximum => 60

  def authenticate(login, password)

  end

  def test_connection

  end

  def auth_method_name

    "Abstract"

  end

  def account_password

    read_ciphered_attribute(:account_password)

  end

  def account_password=(arg)

    write_ciphered_attribute(:account_password, arg)

  end

  def searchable?

    false

  end

  def self.search(q)

    results = []

    AuthSource.all.each do |source|

      begin

        if source.searchable?

          results += source.search(q)

        end

      rescue AuthSourceException => e

        logger.error "Error while searching users in #{source.name}: #{e.message}"

      end

    end

    results

  end

  def allow_password_changes?

    self.class.allow_password_changes?

  end

  # Does this auth source backend allow password changes?

  def self.allow_password_changes?

    false

  end

  # Try to authenticate a user not yet registered against available sources

  def self.authenticate(login, password)

    AuthSource.where(:onthefly_register => true).all.each do |source|

      begin

        logger.debug "Authenticating '#{login}' against '#{source.name}'" if logger && logger.debug?

        attrs = source.authenticate(login, password)

      rescue => e

        logger.error "Error during authentication: #{e.message}"

        attrs = nil

      end

      return attrs if attrs

    end

    return nil

  end

end

# Redmine - project management software

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

  def setup

    @klass = Redmine::Plugin

    # In case some real plugins are installed

    @klass.clear

  end

  def teardown

    @klass.clear

  end

  def test_register

    @klass.register :foo do

      name 'Foo plugin'

      url 'http://example.net/plugins/foo'

      author 'John Smith'

      author_url 'http://example.net/jsmith'

      description 'This is a test plugin'

      version '0.0.1'

      settings :default => {'sample_setting' => 'value', 'foo'=>'bar'}, :partial => 'foo/settings'

    end

    assert_equal 1, @klass.all.size

    plugin = @klass.find('foo')

    assert plugin.is_a?(Redmine::Plugin)

    assert_equal :foo, plugin.id

    assert_equal 'Foo plugin', plugin.name

    assert_equal 'http://example.net/plugins/foo', plugin.url

    assert_equal 'John Smith', plugin.author

    assert_equal 'http://example.net/jsmith', plugin.author_url

    assert_equal 'This is a test plugin', plugin.description

    assert_equal '0.0.1', plugin.version

  end

  def test_installed

    @klass.register(:foo) {}

    assert_equal true, @klass.installed?(:foo)

    assert_equal false, @klass.installed?(:bar)

  end

  def test_menu

    assert_difference 'Redmine::MenuManager.items(:project_menu).size' do

      @klass.register :foo do

        menu :project_menu, :foo_menu_item, '/foo', :caption => 'Foo'

      end

    end

    menu_item = Redmine::MenuManager.items(:project_menu).detect {|i| i.name == :foo_menu_item}

    assert_not_nil menu_item

    assert_equal 'Foo', menu_item.caption

    assert_equal '/foo', menu_item.url

  end

  def test_delete_menu_item

    Redmine::MenuManager.map(:project_menu).push(:foo_menu_item, '/foo', :caption => 'Foo')

    assert_difference 'Redmine::MenuManager.items(:project_menu).size', -1 do

      @klass.register :foo do

        delete_menu_item :project_menu, :foo_menu_item

      end

    end

    assert_nil Redmine::MenuManager.items(:project_menu).detect {|i| i.name == :foo_menu_item}

  end

  def test_requires_redmine

    plugin = Redmine::Plugin.register(:foo) {}

    Redmine::VERSION.stubs(:to_a).returns([2, 1, 3, "stable", 10817])

    # Specific version without hash

    assert plugin.requires_redmine('2.1.3')

    assert plugin.requires_redmine('2.1')

    assert_raise Redmine::PluginRequirementError do

      plugin.requires_redmine('2.1.4')

    end

    assert_raise Redmine::PluginRequirementError do

      plugin.requires_redmine('2.2')

    end

    # Specific version

    assert plugin.requires_redmine(:version => '2.1.3')

    assert plugin.requires_redmine(:version => ['2.1.3', '2.2.0'])

    assert plugin.requires_redmine(:version => '2.1')

    assert_raise Redmine::PluginRequirementError do

      plugin.requires_redmine(:version => '2.2.0')

    end

    assert_raise Redmine::PluginRequirementError do

      plugin.requires_redmine(:version => ['2.1.4', '2.2.0'])

    end

    assert_raise Redmine::PluginRequirementError do

      plugin.requires_redmine(:version => '2.2')

    end

    # Version range

    assert plugin.requires_redmine(:version => '2.0.0'..'2.2.4')

    assert plugin.requires_redmine(:version => '2.1.3'..'2.2.4')

    assert plugin.requires_redmine(:version => '2.0.0'..'2.1.3')

    assert plugin.requires_redmine(:version => '2.0'..'2.2')

    assert plugin.requires_redmine(:version => '2.1'..'2.2')

    assert plugin.requires_redmine(:version => '2.0'..'2.1')

    assert_raise Redmine::PluginRequirementError do

      plugin.requires_redmine(:version => '2.1.4'..'2.2.4')

    end

    # Version or higher

    assert plugin.requires_redmine(:version_or_higher => '0.1.0')

    assert plugin.requires_redmine(:version_or_higher => '2.1.3')

    assert plugin.requires_redmine(:version_or_higher => '2.1')

    assert_raise Redmine::PluginRequirementError do

      plugin.requires_redmine(:version_or_higher => '2.2.0')

    end

    assert_raise Redmine::PluginRequirementError do

      plugin.requires_redmine(:version_or_higher => '2.2')

    end

  end

  def test_requires_redmine_plugin

    test = self

    other_version = '0.5.0'

    @klass.register :other do

      name 'Other'

      version other_version

    end

    @klass.register :foo do

      test.assert requires_redmine_plugin(:other, :version_or_higher => '0.1.0')

      test.assert requires_redmine_plugin(:other, :version_or_higher => other_version)

      test.assert requires_redmine_plugin(:other, other_version)

      test.assert_raise Redmine::PluginRequirementError do

        requires_redmine_plugin(:other, :version_or_higher => '99.0.0')

      end

      test.assert requires_redmine_plugin(:other, :version => other_version)

      test.assert requires_redmine_plugin(:other, :version => [other_version, '99.0.0'])

      test.assert_raise Redmine::PluginRequirementError do

        requires_redmine_plugin(:other, :version => '99.0.0')

      end

      test.assert_raise Redmine::PluginRequirementError do

        requires_redmine_plugin(:other, :version => ['98.0.0', '99.0.0'])

      end

      # Missing plugin

      test.assert_raise Redmine::PluginNotFound do

        requires_redmine_plugin(:missing, :version_or_higher => '0.1.0')

      end

      test.assert_raise Redmine::PluginNotFound do

        requires_redmine_plugin(:missing, '0.1.0')

      end

      test.assert_raise Redmine::PluginNotFound do

        requires_redmine_plugin(:missing, :version => '0.1.0')

      end

    end

  end

end

# Redmine - project management software

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

  fixtures :projects, :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions

  def setup

    @wiki = Wiki.find(1)

    @page = @wiki.pages.first

  end

  def test_create

    page = WikiPage.new(:wiki => @wiki)

    assert !page.save

    assert_equal 1, page.errors.count

    page.title = "Page"

    assert page.save

    page.reload

    assert !page.protected?

    @wiki.reload

    assert @wiki.pages.include?(page)

  end

  def test_sidebar_should_be_protected_by_default

    page = @wiki.find_or_new_page('sidebar')

    assert page.new_record?

    assert page.protected?

  end

  def test_find_or_new_page

    page = @wiki.find_or_new_page("CookBook documentation")

    assert_kind_of WikiPage, page

    assert !page.new_record?

    page = @wiki.find_or_new_page("Non existing page")

    assert_kind_of WikiPage, page

    assert page.new_record?

  end

  def test_parent_title

    page = WikiPage.find_by_title('Another_page')

    assert_nil page.parent_title

    page = WikiPage.find_by_title('Page_with_an_inline_image')

    assert_equal 'CookBook documentation', page.parent_title

  end

  def test_assign_parent

    page = WikiPage.find_by_title('Another_page')

    page.parent_title = 'CookBook documentation'

    assert page.save

    page.reload

    assert_equal WikiPage.find_by_title('CookBook_documentation'), page.parent

  end

  def test_unassign_parent

    page = WikiPage.find_by_title('Page_with_an_inline_image')

    page.parent_title = ''

    assert page.save

    page.reload

    assert_nil page.parent

  end

  def test_parent_validation

    page = WikiPage.find_by_title('CookBook_documentation')

    # A page that doesn't exist

    page.parent_title = 'Unknown title'

    assert !page.save

    assert_include I18n.translate('activerecord.errors.messages.invalid'),

                   page.errors[:parent_title]

    # A child page

    page.parent_title = 'Page_with_an_inline_image'

    assert !page.save

    assert_include I18n.translate('activerecord.errors.messages.circular_dependency'),

                   page.errors[:parent_title]

    # The page itself

    page.parent_title = 'CookBook_documentation'

    assert !page.save

    assert_include I18n.translate('activerecord.errors.messages.circular_dependency'),

                   page.errors[:parent_title]

    page.parent_title = 'Another_page'

    assert page.save

  end

  def test_destroy

    page = WikiPage.find(1)

    page.destroy

    assert_nil WikiPage.find_by_id(1)

    # make sure that page content and its history are deleted

    assert WikiContent.find_all_by_page_id(1).empty?

    assert WikiContent.versioned_class.find_all_by_page_id(1).empty?

  end

  def test_destroy_should_not_nullify_children

    page = WikiPage.find(2)

    child_ids = page.child_ids

    assert child_ids.any?

    page.destroy

    assert_nil WikiPage.find_by_id(2)

    children = WikiPage.find_all_by_id(child_ids)

    assert_equal child_ids.size, children.size

    children.each do |child|

      assert_nil child.parent_id

    end

  end

  def test_updated_on_eager_load

    page = WikiPage.with_updated_on.first(:order => 'id')

    assert page.is_a?(WikiPage)

    assert_not_nil page.read_attribute(:updated_on)

    assert_equal Time.gm(2007, 3, 6, 23, 10, 51), page.content.updated_on

    assert_equal page.content.updated_on, page.updated_on

    assert_not_nil page.read_attribute(:version)

  end

  def test_descendants

    page = WikiPage.create!(:wiki => @wiki, :title => 'Parent')

    child1 = WikiPage.create!(:wiki => @wiki, :title => 'Child1', :parent => page)

    child11 = WikiPage.create!(:wiki => @wiki, :title => 'Child11', :parent => child1)

    child111 = WikiPage.create!(:wiki => @wiki, :title => 'Child111', :parent => child11)

    child2 = WikiPage.create!(:wiki => @wiki, :title => 'Child2', :parent => page)

    assert_equal %w(Child1 Child11 Child111 Child2), page.descendants.map(&:title).sort

    assert_equal %w(Child1 Child11 Child111 Child2), page.descendants(nil).map(&:title).sort

    assert_equal %w(Child1 Child11 Child2), page.descendants(2).map(&:title).sort

    assert_equal %w(Child1 Child2), page.descendants(1).map(&:title).sort

    assert_equal %w(Child1 Child11 Child111 Child2 Parent), page.self_and_descendants.map(&:title).sort

    assert_equal %w(Child1 Child11 Child111 Child2 Parent), page.self_and_descendants(nil).map(&:title).sort

    assert_equal %w(Child1 Child11 Child2 Parent), page.self_and_descendants(2).map(&:title).sort

    assert_equal %w(Child1 Child2 Parent), page.self_and_descendants(1).map(&:title).sort

  end

  def test_diff_for_page_with_deleted_version_should_pick_the_previous_available_version

    WikiContent::Version.find_by_page_id_and_version(1, 2).destroy

    page = WikiPage.find(1)

    diff = page.diff(3)

    assert_not_nil diff

    assert_equal 3, diff.content_to.version

    assert_equal 1, diff.content_from.version

  end

end

# Redmine - project management software

# Copyright (C) 2006-2013  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 RoutingJournalsTest < ActionController::IntegrationTest

  def test_journals

    assert_routing(

        { :method => 'post', :path => "/issues/1/quoted" },

        { :controller => 'journals', :action => 'new', :id => '1' }

      )

    assert_routing(

        { :method => 'get', :path => "/issues/changes" },

        { :controller => 'journals', :action => 'index' }

      )

    assert_routing(

        { :method => 'get', :path => "/journals/diff/1" },

        { :controller => 'journals', :action => 'diff', :id => '1' }

      )

    ["get", "post"].each do |method|

      assert_routing(

          { :method => method, :path => "/journals/edit/1" },

          { :controller => 'journals', :action => 'edit', :id => '1' }

        )

    end

  end

end

# Redmine - project management software

# Copyright (C) 2006-2013  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.

class News < ActiveRecord::Base

  include Redmine::SafeAttributes

  belongs_to :project

  belongs_to :author, :class_name => 'User', :foreign_key => 'author_id'

  has_many :comments, :as => :commented, :dependent => :delete_all, :order => "created_on"

  validates_presence_of :title, :description

  validates_length_of :title, :maximum => 60

  validates_length_of :summary, :maximum => 255

  acts_as_attachable :delete_permission => :manage_news

  acts_as_searchable :columns => ['title', 'summary', "#{table_name}.description"], :include => :project

  acts_as_event :url => Proc.new {|o| {:controller => 'news', :action => 'show', :id => o.id}}

  acts_as_activity_provider :find_options => {:include => [:project, :author]},

                            :author_key => :author_id

  acts_as_watchable

  after_create :add_author_as_watcher

  scope :visible, lambda {|*args|

    includes(:project).where(Project.allowed_to_condition(args.shift || User.current, :view_news, *args))

  }

  safe_attributes 'title', 'summary', 'description'

  def visible?(user=User.current)

    !user.nil? && user.allowed_to?(:view_news, project)

  end

  # Returns true if the news can be commented by user

  def commentable?(user=User.current)

    user.allowed_to?(:comment_news, project)

  end

  def recipients

    project.users.select {|user| user.notify_about?(self)}.map(&:mail)

  end

  # returns latest news for projects visible by user

  def self.latest(user = User.current, count = 5)

    visible(user).includes([:author, :project]).order("#{News.table_name}.created_on DESC").limit(count).all

  end

  private

  def add_author_as_watcher

    Watcher.create(:watchable => self, :user => author)

  end

end

# Redmine - project management software

# Copyright (C) 2006-2013  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::ApiTest::GroupsTest < Redmine::ApiTest::Base

  fixtures :users, :groups_users

  def setup

    Setting.rest_api_enabled = '1'

  end

  context "GET /groups" do

    context ".xml" do

      should "require authentication" do

        get '/groups.xml'

        assert_response 401

      end

      should "return groups" do

        get '/groups.xml', {}, credentials('admin')

        assert_response :success

        assert_equal 'application/xml', response.content_type

        assert_select 'groups' do

          assert_select 'group' do

            assert_select 'name', :text => 'A Team'

            assert_select 'id', :text => '10'

          end

        end

      end

    end

    context ".json" do

      should "require authentication" do

        get '/groups.json'

        assert_response 401

      end

      should "return groups" do

        get '/groups.json', {}, credentials('admin')

        assert_response :success

        assert_equal 'application/json', response.content_type

        json = MultiJson.load(response.body)

        groups = json['groups']

        assert_kind_of Array, groups

        group = groups.detect {|g| g['name'] == 'A Team'}

        assert_not_nil group

        assert_equal({'id' => 10, 'name' => 'A Team'}, group)

      end

    end

  end

  context "GET /groups/:id" do

    context ".xml" do

      should "return the group with its users" do

        get '/groups/10.xml', {}, credentials('admin')

        assert_response :success

        assert_equal 'application/xml', response.content_type

        assert_select 'group' do

          assert_select 'name', :text => 'A Team'

          assert_select 'id', :text => '10'

        end

      end

      should "include users if requested" do

        get '/groups/10.xml?include=users', {}, credentials('admin')

        assert_response :success

        assert_equal 'application/xml', response.content_type

        assert_select 'group' do

          assert_select 'users' do

            assert_select 'user', Group.find(10).users.count

            assert_select 'user[id=8]'

          end

        end

      end

      should "include memberships if requested" do

        get '/groups/10.xml?include=memberships', {}, credentials('admin')

        assert_response :success

        assert_equal 'application/xml', response.content_type

        assert_select 'group' do

          assert_select 'memberships'

        end

      end

    end

  end

  context "POST /groups" do

    context "with valid parameters" do

      context ".xml" do

        should "create groups" do

          assert_difference('Group.count') do

            post '/groups.xml', {:group => {:name => 'Test', :user_ids => [2, 3]}}, credentials('admin')

            assert_response :created

            assert_equal 'application/xml', response.content_type

          end

          group = Group.order('id DESC').first

          assert_equal 'Test', group.name

          assert_equal [2, 3], group.users.map(&:id).sort

          assert_select 'group' do

            assert_select 'name', :text => 'Test'

          end

        end

      end

    end

    context "with invalid parameters" do

      context ".xml" do

        should "return errors" do

          assert_no_difference('Group.count') do

            post '/groups.xml', {:group => {:name => ''}}, credentials('admin')

          end

          assert_response :unprocessable_entity

          assert_equal 'application/xml', response.content_type

          assert_select 'errors' do

            assert_select 'error', :text => /Name can't be blank/

          end

        end

      end

    end

  end

  context "PUT /groups/:id" do

    context "with valid parameters" do

      context ".xml" do

        should "update the group" do

          put '/groups/10.xml', {:group => {:name => 'New name', :user_ids => [2, 3]}}, credentials('admin')

          assert_response :ok

          assert_equal '', @response.body

          group = Group.find(10)

          assert_equal 'New name', group.name

          assert_equal [2, 3], group.users.map(&:id).sort

        end

      end

    end

    context "with invalid parameters" do

      context ".xml" do

        should "return errors" do

          put '/groups/10.xml', {:group => {:name => ''}}, credentials('admin')

          assert_response :unprocessable_entity

          assert_equal 'application/xml', response.content_type

          assert_select 'errors' do

            assert_select 'error', :text => /Name can't be blank/

          end

        end

      end

    end

  end

  context "DELETE /groups/:id" do

    context ".xml" do

      should "delete the group" do

        assert_difference 'Group.count', -1 do

          delete '/groups/10.xml', {}, credentials('admin')

          assert_response :ok

          assert_equal '', @response.body

        end

      end

    end

  end

  context "POST /groups/:id/users" do

    context ".xml" do

      should "add user to the group" do

        assert_difference 'Group.find(10).users.count' do

          post '/groups/10/users.xml', {:user_id => 5}, credentials('admin')

          assert_response :ok

          assert_equal '', @response.body

        end

        assert_include User.find(5), Group.find(10).users

      end

    end

  end

  context "DELETE /groups/:id/users/:user_id" do

    context ".xml" do

      should "remove user from the group" do

        assert_difference 'Group.find(10).users.count', -1 do

          delete '/groups/10/users/8.xml', {}, credentials('admin')

          assert_response :ok

          assert_equal '', @response.body

        end

        assert_not_include User.find(8), Group.find(10).users

      end

    end

  end

end