SoundSoftware Code Site

# Redmine - project management software

# Copyright (C) 2006-2012  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__)

begin

  require 'mocha'

  class SubversionAdapterTest < ActiveSupport::TestCase

    if repository_configured?('subversion')

      def setup

        @adapter = Redmine::Scm::Adapters::SubversionAdapter.new(self.class.subversion_repository_url)

      end

      def test_client_version

        v = Redmine::Scm::Adapters::SubversionAdapter.client_version

        assert v.is_a?(Array)

      end

      def test_scm_version

        to_test = { "svn, version 1.6.13 (r1002816)\n"  => [1,6,13],

                    "svn, versione 1.6.13 (r1002816)\n" => [1,6,13],

                    "1.6.1\n1.7\n1.8"                   => [1,6,1],

                    "1.6.2\r\n1.8.1\r\n1.9.1"           => [1,6,2]}

        to_test.each do |s, v|

          test_scm_version_for(s, v)

        end

      end

      def test_info_not_nil

        assert_not_nil @adapter.info

      end

      def test_info_nil

        adpt = Redmine::Scm::Adapters::SubversionAdapter.new(

                  "file:///invalid/invalid/"

                  )

        assert_nil adpt.info

      end

      private

      def test_scm_version_for(scm_version, version)

        @adapter.class.expects(:scm_version_from_command_line).returns(scm_version)

        assert_equal version, @adapter.class.svn_binary_version

      end

    else

      puts "Subversion test repository NOT FOUND. Skipping unit tests !!!"

      def test_fake; assert true end

    end

  end

rescue LoadError

  class SubversionMochaFake < ActiveSupport::TestCase

    def test_fake; assert(false, "Requires mocha to run those tests")  end

  end

end

<%= labelled_form_for @project do |f| %>

<%= render :partial => 'form', :locals => { :f => f } %>

<%= submit_tag l(:button_save) %>

<% end %>

# Redmine - project management software

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

  fixtures :projects, :users, :members, :member_roles, :roles,

           :trackers, :projects_trackers,

           :versions,

           :issue_statuses, :issue_categories, :issue_relations, :workflows,

           :enumerations,

           :issues,

           :custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,

           :time_entries

  self.use_transactional_fixtures = false

  def test_invalid_move_to_another_project

    parent1 = Issue.generate!

    child =   Issue.generate!(:parent_issue_id => parent1.id)

    grandchild = Issue.generate!(:parent_issue_id => child.id, :tracker_id => 2)

    Project.find(2).tracker_ids = [1]

    parent1.reload

    assert_equal [1, parent1.id, 1, 6], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]

    # child can not be moved to Project 2 because its child is on a disabled tracker

    child = Issue.find(child.id)

    child.project = Project.find(2)

    assert !child.save

    child.reload

    grandchild.reload

    parent1.reload

    # no change

    assert_equal [1, parent1.id, 1, 6], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]

    assert_equal [1, parent1.id, 2, 5], [child.project_id, child.root_id, child.lft, child.rgt]

    assert_equal [1, parent1.id, 3, 4], [grandchild.project_id, grandchild.root_id, grandchild.lft, grandchild.rgt]

  end

end

# Redmine - project management software

# Copyright (C) 2006-2012  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 QueriesController < ApplicationController

  menu_item :issues

  before_filter :find_query, :except => [:new, :create, :index]

  before_filter :find_optional_project, :only => [:new, :create]

  accept_api_auth :index

  include QueriesHelper

  def index

    case params[:format]

    when 'xml', 'json'

      @offset, @limit = api_offset_and_limit

    else

      @limit = per_page_option

    end

    @query_count = Query.visible.count

    @query_pages = Paginator.new self, @query_count, @limit, params['page']

    @queries = Query.visible.all(:limit => @limit, :offset => @offset, :order => "#{Query.table_name}.name")

    respond_to do |format|

      format.html { render :nothing => true }

      format.api

    end

  end

  def new

    @query = Query.new

    @query.user = User.current

    @query.project = @project

    @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?

    build_query_from_params

  end

  def create

    @query = Query.new(params[:query])

    @query.user = User.current

    @query.project = params[:query_is_for_all] ? nil : @project

    @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?

    build_query_from_params

    @query.column_names = nil if params[:default_columns]

    if @query.save

      flash[:notice] = l(:notice_successful_create)

      redirect_to :controller => 'issues', :action => 'index', :project_id => @project, :query_id => @query

    else

      render :action => 'new', :layout => !request.xhr?

    end

  end

  def edit

  end

  def update

    @query.attributes = params[:query]

    @query.project = nil if params[:query_is_for_all]

    @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?

    build_query_from_params

    @query.column_names = nil if params[:default_columns]

    if @query.save

      flash[:notice] = l(:notice_successful_update)

      redirect_to :controller => 'issues', :action => 'index', :project_id => @project, :query_id => @query

    else

      render :action => 'edit'

    end

  end

  def destroy

    @query.destroy

    redirect_to :controller => 'issues', :action => 'index', :project_id => @project, :set_filter => 1

  end

private

  def find_query

    @query = Query.find(params[:id])

    @project = @query.project

    render_403 unless @query.editable_by?(User.current)

  rescue ActiveRecord::RecordNotFound

    render_404

  end

  def find_optional_project

    @project = Project.find(params[:project_id]) if params[:project_id]

    render_403 unless User.current.allowed_to?(:save_queries, @project, :global => true)

  rescue ActiveRecord::RecordNotFound

    render_404

  end

end

var revisionGraph = null;

function drawRevisionGraph(holder, commits_hash, graph_space) {

    var XSTEP = 20,

        CIRCLE_INROW_OFFSET = 10;

    var commits_by_scmid = commits_hash,

        commits = $.map(commits_by_scmid, function(val,i){return val;});

    var max_rdmid = commits.length - 1;

    var commit_table_rows = $('table.changesets tr.changeset');

    // create graph

    if(revisionGraph != null)

        revisionGraph.clear();

    else

        revisionGraph = Raphael(holder);

    var top = revisionGraph.set();

    // init dimensions

    var graph_x_offset = commit_table_rows.first().find('td').first().position().left - $(holder).position().left,

        graph_y_offset = $(holder).position().top,

        graph_right_side = graph_x_offset + (graph_space + 1) * XSTEP,

        graph_bottom = commit_table_rows.last().position().top + commit_table_rows.last().height() - graph_y_offset;

    revisionGraph.setSize(graph_right_side, graph_bottom);

    // init colors

    var colors = [];

    Raphael.getColor.reset();

    for (var k = 0; k <= graph_space; k++) {

        colors.push(Raphael.getColor());

    }

    var parent_commit;

    var x, y, parent_x, parent_y;

    var path, title;

    var revision_dot_overlay;

    $.each(commits, function(index, commit) {

        if (!commit.hasOwnProperty("space"))

            commit.space = 0;

        y = commit_table_rows.eq(max_rdmid - commit.rdmid).position().top - graph_y_offset + CIRCLE_INROW_OFFSET;

        x = graph_x_offset + XSTEP / 2 + XSTEP * commit.space;

        revisionGraph.circle(x, y, 3)

            .attr({

                fill: colors[commit.space],

                stroke: 'none',

            }).toFront();

        // paths to parents

        $.each(commit.parent_scmids, function(index, parent_scmid) {

            parent_commit = commits_by_scmid[parent_scmid];

            if (parent_commit) {

                if (!parent_commit.hasOwnProperty("space"))

                    parent_commit.space = 0;

                parent_y = commit_table_rows.eq(max_rdmid - parent_commit.rdmid).position().top - graph_y_offset + CIRCLE_INROW_OFFSET;

                parent_x = graph_x_offset + XSTEP / 2 + XSTEP * parent_commit.space;

                if (parent_commit.space == commit.space) {

                    // vertical path

                    path = revisionGraph.path([

                        'M', x, y,

                        'V', parent_y]);

                } else {

                    // path to a commit in a different branch (Bezier curve)

                    path = revisionGraph.path([

                        'M', x, y,

                        'C', x, y, x, y + (parent_y - y) / 2, x + (parent_x - x) / 2, y + (parent_y - y) / 2,

                        'C', x + (parent_x - x) / 2, y + (parent_y - y) / 2, parent_x, parent_y-(parent_y-y)/2, parent_x, parent_y]);

                }

            } else {

                // vertical path ending at the bottom of the revisionGraph

                path = revisionGraph.path([

                    'M', x, y,

                    'V', graph_bottom]);

            }

            path.attr({stroke: colors[commit.space], "stroke-width": 1.5}).toBack();

        });

        revision_dot_overlay = revisionGraph.circle(x, y, 10);

        revision_dot_overlay

            .attr({

                fill: '#000',

                opacity: 0,

                cursor: 'pointer', 

                href: commit.href

            });

        if(commit.refs != null && commit.refs.length > 0) {

            title = document.createElementNS(revisionGraph.canvas.namespaceURI, 'title');

            title.appendChild(document.createTextNode(commit.refs));

            revision_dot_overlay.node.appendChild(title);

        }

        top.push(revision_dot_overlay);

    });

    top.toFront();

};

# Redmine - project management software

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

  include Redmine::I18n

  fixtures :auth_sources

  def setup

  end

  def test_create

    a = AuthSourceLdap.new(:name => 'My LDAP', :host => 'ldap.example.net', :port => 389, :base_dn => 'dc=example,dc=net', :attr_login => 'sAMAccountName')

    assert a.save

  end

  def test_should_strip_ldap_attributes

    a = AuthSourceLdap.new(:name => 'My LDAP', :host => 'ldap.example.net', :port => 389, :base_dn => 'dc=example,dc=net', :attr_login => 'sAMAccountName',

                           :attr_firstname => 'givenName ')

    assert a.save

    assert_equal 'givenName', a.reload.attr_firstname

  end

  def test_replace_port_zero_to_389

    a = AuthSourceLdap.new(

           :name => 'My LDAP', :host => 'ldap.example.net', :port => 0,

           :base_dn => 'dc=example,dc=net', :attr_login => 'sAMAccountName',

           :attr_firstname => 'givenName ')

    assert a.save

    assert_equal 389, a.port

  end

  def test_filter_should_be_validated

    set_language_if_valid 'en'

    a = AuthSourceLdap.new(:name => 'My LDAP', :host => 'ldap.example.net', :port => 389, :attr_login => 'sn')

    a.filter = "(mail=*@redmine.org"

    assert !a.valid?

    assert_include "LDAP filter is invalid", a.errors.full_messages

    a.filter = "(mail=*@redmine.org)"

    assert a.valid?

  end

  if ldap_configured?

    context '#authenticate' do

      setup do

        @auth = AuthSourceLdap.find(1)

        @auth.update_attribute :onthefly_register, true

      end

      context 'with a valid LDAP user' do

        should 'return the user attributes' do

          attributes =  @auth.authenticate('example1','123456')

          assert attributes.is_a?(Hash), "An hash was not returned"

          assert_equal 'Example', attributes[:firstname]

          assert_equal 'One', attributes[:lastname]

          assert_equal 'example1@redmine.org', attributes[:mail]

          assert_equal @auth.id, attributes[:auth_source_id]

          attributes.keys.each do |attribute|

            assert User.new.respond_to?("#{attribute}="), "Unexpected :#{attribute} attribute returned"

          end

        end

      end

      context 'with an invalid LDAP user' do

        should 'return nil' do

          assert_equal nil, @auth.authenticate('nouser','123456')

        end

      end

      context 'without a login' do

        should 'return nil' do

          assert_equal nil, @auth.authenticate('','123456')

        end

      end

      context 'without a password' do

        should 'return nil' do

          assert_equal nil, @auth.authenticate('edavis','')

        end

      end

      context 'without filter' do

        should 'return any user' do

          assert @auth.authenticate('example1','123456')

          assert @auth.authenticate('edavis', '123456')

        end

      end

      context 'with filter' do

        setup do

          @auth.filter = "(mail=*@redmine.org)"

        end

        should 'return user who matches the filter only' do

          assert @auth.authenticate('example1','123456')

          assert_nil @auth.authenticate('edavis', '123456')

        end

      end

    end

    def test_authenticate_should_timeout

      auth_source = AuthSourceLdap.find(1)

      auth_source.timeout = 1

      def auth_source.initialize_ldap_con(*args); sleep(5); end

      assert_raise AuthSourceTimeoutException do

        auth_source.authenticate 'example1', '123456'

      end

    end

  else

    puts '(Test LDAP server not configured)'

  end

end

--- 

wikis_001: 

  status: 1

  start_page: CookBook documentation

  project_id: 1

  id: 1

wikis_002: 

  status: 1

  start_page: Start page

  project_id: 2

  id: 2