SoundSoftware Code Site

require File.expand_path('../../../test_helper', __FILE__)

class ApiTest::DisabledRestApiTest < ActionController::IntegrationTest

  fixtures :projects, :trackers, :issue_statuses, :issues,

           :enumerations, :users, :issue_categories,

           :projects_trackers,

           :roles,

           :member_roles,

           :members,

           :enabled_modules,

           :workflows

  def setup

    Setting.rest_api_enabled = '0'

    Setting.login_required = '1'

  end

  def teardown

    Setting.rest_api_enabled = '1'

    Setting.login_required = '0'

  end

  # Using the NewsController because it's a simple API.

  context "get /news with the API disabled" do

    context "in :xml format" do

      context "with a valid api token" do

        setup do

          @user = User.generate_with_protected!

          @token = Token.generate!(:user => @user, :action => 'api')

          get "/news.xml?key=#{@token.value}"

        end

        should_respond_with :unauthorized

        should_respond_with_content_type :xml

        should "not login as the user" do

          assert_equal User.anonymous, User.current

        end

      end

      context "with a valid HTTP authentication" do

        setup do

          @user = User.generate_with_protected!(:password => 'my_password', :password_confirmation => 'my_password')

          @authorization = ActionController::HttpAuthentication::Basic.encode_credentials(@user.login, 'my_password')

          get "/news.xml", nil, :authorization => @authorization

        end

        should_respond_with :unauthorized

        should_respond_with_content_type :xml

        should "not login as the user" do

          assert_equal User.anonymous, User.current

        end

      end

      context "with a valid HTTP authentication using the API token" do

        setup do

          @user = User.generate_with_protected!

          @token = Token.generate!(:user => @user, :action => 'api')

          @authorization = ActionController::HttpAuthentication::Basic.encode_credentials(@token.value, 'X')

          get "/news.xml", nil, :authorization => @authorization

        end

        should_respond_with :unauthorized

        should_respond_with_content_type :xml

        should "not login as the user" do

          assert_equal User.anonymous, User.current

        end

      end

    end

    context "in :json format" do

      context "with a valid api token" do

        setup do

          @user = User.generate_with_protected!

          @token = Token.generate!(:user => @user, :action => 'api')

          get "/news.json?key=#{@token.value}"

        end

        should_respond_with :unauthorized

        should_respond_with_content_type :json

        should "not login as the user" do

          assert_equal User.anonymous, User.current

        end

      end

      context "with a valid HTTP authentication" do

        setup do

          @user = User.generate_with_protected!(:password => 'my_password', :password_confirmation => 'my_password')

          @authorization = ActionController::HttpAuthentication::Basic.encode_credentials(@user.login, 'my_password')

          get "/news.json", nil, :authorization => @authorization

        end

        should_respond_with :unauthorized

        should_respond_with_content_type :json

        should "not login as the user" do

          assert_equal User.anonymous, User.current

        end

      end

      context "with a valid HTTP authentication using the API token" do

        setup do

          @user = User.generate_with_protected!

          @token = Token.generate!(:user => @user, :action => 'api')

          @authorization = ActionController::HttpAuthentication::Basic.encode_credentials(@token.value, 'DoesNotMatter')

          get "/news.json", nil, :authorization => @authorization

        end

        should_respond_with :unauthorized

        should_respond_with_content_type :json

        should "not login as the user" do

          assert_equal User.anonymous, User.current

        end

      end

    end

  end

end

# 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 'redmine/scm/adapters/darcs_adapter'

class Repository::Darcs < Repository

  validates_presence_of :url, :log_encoding

  def self.human_attribute_name(attribute_key_name)

    attr_name = attribute_key_name

    if attr_name == "url"

      attr_name = "path_to_repository"

    end

    super(attr_name)

  end

  def self.scm_adapter_class

    Redmine::Scm::Adapters::DarcsAdapter

  end

  def self.scm_name

    'Darcs'

  end

  def supports_directory_revisions?

    true

  end

  def entry(path=nil, identifier=nil)

    patch = identifier.nil? ? nil : changesets.find_by_revision(identifier)

    scm.entry(path, patch.nil? ? nil : patch.scmid)

  end

  def entries(path=nil, identifier=nil)

    patch = nil

    if ! identifier.nil?

      patch = changesets.find_by_revision(identifier)

      return nil if patch.nil?

    end

    entries = scm.entries(path, patch.nil? ? nil : patch.scmid)

    if entries

      entries.each do |entry|

        # Search the DB for the entry's last change

        if entry.lastrev && !entry.lastrev.scmid.blank?

          changeset = changesets.find_by_scmid(entry.lastrev.scmid)

        end

        if changeset

          entry.lastrev.identifier = changeset.revision

          entry.lastrev.name       = changeset.revision

          entry.lastrev.time       = changeset.committed_on

          entry.lastrev.author     = changeset.committer

        end

      end

    end

    entries

  end

  def cat(path, identifier=nil)

    patch = identifier.nil? ? nil : changesets.find_by_revision(identifier.to_s)

    scm.cat(path, patch.nil? ? nil : patch.scmid)

  end

  def diff(path, rev, rev_to)

    patch_from = changesets.find_by_revision(rev)

    return nil if patch_from.nil?

    patch_to = changesets.find_by_revision(rev_to) if rev_to

    if path.blank?

      path = patch_from.changes.collect{|change| change.path}.join(' ')

    end

    patch_from ? scm.diff(path, patch_from.scmid, patch_to ? patch_to.scmid : nil) : nil

  end

  def fetch_changesets

    scm_info = scm.info

    if scm_info

      db_last_id = latest_changeset ? latest_changeset.scmid : nil

      next_rev   = latest_changeset ? latest_changeset.revision.to_i + 1 : 1

      # latest revision in the repository

      scm_revision = scm_info.lastrev.scmid

      unless changesets.find_by_scmid(scm_revision)

        revisions = scm.revisions('', db_last_id, nil, :with_path => true)

        transaction do

          revisions.reverse_each do |revision|

            changeset = Changeset.create(:repository   => self,

                                         :revision     => next_rev,

                                         :scmid        => revision.scmid,

                                         :committer    => revision.author,

                                         :committed_on => revision.time,

                                         :comments     => revision.message)

            revision.paths.each do |change|

              changeset.create_change(change)

            end

            next_rev += 1

          end if revisions

        end

      end

    end

  end

end

<h2><%= l(:label_search) %></h2>

<div class="box">

<% form_tag({}, :method => :get) do %>

<%= label_tag "search-input", l(:description_search), :class => "hidden-for-sighted" %>

<p><%= text_field_tag 'q', @question, :size => 60, :id => 'search-input' %>

<%= javascript_tag "Field.focus('search-input')" %>

<%= project_select_tag %>

<%= hidden_field_tag 'all_words', '', :id => nil %>

<label><%= check_box_tag 'all_words', 1, @all_words %> <%= l(:label_all_words) %></label>

<%= hidden_field_tag 'titles_only', '', :id => nil %>

<label><%= check_box_tag 'titles_only', 1, @titles_only %> <%= l(:label_search_titles_only) %></label>

</p>

<p>

<% @object_types.each do |t| %>

<label><%= check_box_tag t, 1, @scope.include?(t) %> <%= type_label(t) %></label>

<% end %>

</p>

<p><%= submit_tag l(:button_submit), :name => 'submit' %></p>

<% end %>

</div>

<% if @results %>

    <div id="search-results-counts">

    <%= render_results_by_type(@results_by_type) unless @scope.size == 1 %>

    </div>

    <h3><%= l(:label_result_plural) %> (<%= @results_by_type.values.sum %>)</h3>

    <dl id="search-results">

      <% @results.each do |e| %>

        <dt class="<%= e.event_type %>"><%= content_tag('span', h(e.project), :class => 'project') unless @project == e.project %> <%= link_to highlight_tokens(truncate(h(e.event_title), :length => 255), @tokens), e.event_url %></dt>

        <dd><span class="description"><%= highlight_tokens(h(e.event_description), @tokens) %></span>

        <span class="author"><%= format_time(e.event_datetime) %></span></dd>

      <% end %>

    </dl>

<% end %>

<p><center>

<% if @pagination_previous_date %>

<%= link_to_content_update("\xc2\xab " + l(:label_previous),

      params.merge(:previous => 1,

                   :offset => @pagination_previous_date.strftime("%Y%m%d%H%M%S"))) %> 

<% end %>

<% if @pagination_next_date %>

<%= link_to_content_update(l(:label_next) + " \xc2\xbb",

      params.merge(:previous => nil,

                   :offset => @pagination_next_date.strftime("%Y%m%d%H%M%S"))) %>

<% end %>

</center></p>

<% html_title(l(:label_search)) -%>

RUBYTREE - http://rubytree.rubyforge.org

========================================

Copyright (c) 2006, 2007 Anupam Sengupta

All rights reserved.

Redistribution and use in source and binary forms, with or without modification,

are permitted provided that the following conditions are met:

- Redistributions of source code must retain the above copyright notice, this

  list of conditions and the following disclaimer.

- Redistributions in binary form must reproduce the above copyright notice, this

  list of conditions and the following disclaimer in the documentation and/or

  other materials provided with the distribution.

- Neither the name of the organization nor the names of its contributors may

  be used to endorse or promote products derived from this software without

  specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR

ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# This code lets us redefine existing Rake tasks, which is extremely

# handy for modifying existing Rails rake tasks.

# Credit for the original snippet of code goes to Jeremy Kemper

# http://pastie.caboo.se/9620

unless Rake::TaskManager.methods.include?('redefine_task')

  module Rake

    module TaskManager

      def redefine_task(task_class, args, &block)

        task_name, arg_names, deps = resolve_args([args])

        task_name = task_class.scope_name(@scope, task_name)

        deps = [deps] unless deps.respond_to?(:to_ary)

        deps = deps.collect {|d| d.to_s }

        task = @tasks[task_name.to_s] = task_class.new(task_name, self)

        task.application = self

        task.add_description(@last_description)

        @last_description = nil

        task.enhance(deps, &block)

        task

      end

    end

    class Task

      class << self

        def redefine_task(args, &block)

          Rake.application.redefine_task(self, [args], &block)

        end

      end

    end

  end

end

namespace :db do

  namespace :migrate do

    desc 'Migrate database and plugins to current status.'

    task :all => [ 'db:migrate', 'db:migrate:plugins' ]

    desc 'Migrate plugins to current status.'

    task :plugins => :environment do

      Engines.plugins.each do |plugin|

        next unless plugin.respond_to?(:migration_directory)

        next unless File.exists? plugin.migration_directory

        puts "Migrating plugin #{plugin.name} ..."

        plugin.migrate

      end

    end

    desc 'For engines coming from Rails version < 2.0 or for those previously updated to work with Sven Fuch\'s fork of engines, you need to upgrade the schema info table'

    task :upgrade_plugin_migrations => :environment do

      svens_fork_table_name = 'plugin_schema_migrations'

      # Check if app was previously using Sven's fork

      if ActiveRecord::Base.connection.table_exists?(svens_fork_table_name)

        old_sm_table = svens_fork_table_name

      else

        old_sm_table = ActiveRecord::Migrator.proper_table_name(Engines.schema_info_table)

      end

      unless ActiveRecord::Base.connection.table_exists?(old_sm_table)

        abort "Cannot find old migration table - assuming nothing needs to be done"

      end

      # There are two forms of the engines schema info - pre-fix_plugin_migrations and post

      # We need to figure this out before we continue.

      results = ActiveRecord::Base.connection.select_rows(

        "SELECT version, plugin_name FROM #{old_sm_table}"

      ).uniq

      def insert_new_version(plugin_name, version)

        version_string = "#{version}-#{plugin_name}"

        new_sm_table = ActiveRecord::Migrator.schema_migrations_table_name

        # Check if the row already exists for some reason - maybe run this task more than once.

        return if ActiveRecord::Base.connection.select_rows("SELECT * FROM #{new_sm_table} WHERE version = #{version_string.dump.gsub("\"", "'")}").size > 0

        puts "Inserting new version #{version} for plugin #{plugin_name}.."

        ActiveRecord::Base.connection.insert("INSERT INTO #{new_sm_table} (version) VALUES (#{version_string.dump.gsub("\"", "'")})")

      end

      # We need to figure out if they already used "fix_plugin_migrations"

      versions = {}

      results.each do |r|

        versions[r[1]] ||= []

        versions[r[1]] << r[0].to_i

      end

      if versions.values.find{ |v| v.size > 1 } == nil

        puts "Fixing migration info"

        # We only have one listed migration per plugin - this is pre-fix_plugin_migrations,

        # so we build all versions required. In this case, all migrations should 

        versions.each do |plugin_name, version|

          version = version[0] # There is only one version

          # We have to make an assumption that numeric migrations won't get this long..

          # I'm not sure if there is a better assumption, it should work in all

          # current cases.. (touch wood..)

          if version.to_s.size < "YYYYMMDDHHMMSS".size

            # Insert version records for each migration

            (1..version).each do |v|

             insert_new_version(plugin_name, v)

            end

          else

            # If the plugin is new-format "YYYYMMDDHHMMSS", we just copy it across... 

            # The case in which this occurs is very rare..

            insert_new_version(plugin_name, version)

          end

        end

      else

        puts "Moving migration info"

        # We have multiple migrations listed per plugin - thus we can assume they have

        # already applied fix_plugin_migrations - we just copy it across verbatim

        versions.each do |plugin_name, version|

          version.each { |v| insert_new_version(plugin_name, v) }

        end

      end

      puts "Migration info successfully migrated - removing old schema info table"

      ActiveRecord::Base.connection.drop_table(old_sm_table)

    end

    desc 'Migrate a specified plugin.'

    task(:plugin => :environment) do

      name = ENV['NAME']

      if plugin = Engines.plugins[name]

        version = ENV['VERSION']

        puts "Migrating #{plugin.name} to " + (version ? "version #{version}" : 'latest version') + " ..."

        plugin.migrate(version ? version.to_i : nil)

      else

        puts "Plugin #{name} does not exist."

      end

    end

  end

end

namespace :db do  

  namespace :fixtures do

    namespace :plugins do

      desc "Load plugin fixtures into the current environment's database."

      task :load => :environment do

        require 'active_record/fixtures'

        ActiveRecord::Base.establish_connection(RAILS_ENV.to_sym)

        Dir.glob(File.join(RAILS_ROOT, 'vendor', 'plugins', ENV['PLUGIN'] || '**', 

                 'test', 'fixtures', '*.yml')).each do |fixture_file|

          Fixtures.create_fixtures(File.dirname(fixture_file), File.basename(fixture_file, '.*'))

        end

      end

    end

  end

end

# this is just a modification of the original task in railties/lib/tasks/documentation.rake, 

# because the default task doesn't support subdirectories like <plugin>/app or

# <plugin>/component. These tasks now include every file under a plugin's load paths (see

# Plugin#load_paths).

namespace :doc do

  plugins = FileList['vendor/plugins/**'].collect { |plugin| File.basename(plugin) }

  namespace :plugins do

    # Define doc tasks for each plugin

    plugins.each do |plugin|

      desc "Create plugin documentation for '#{plugin}'"

      Rake::Task.redefine_task(plugin => :environment) do

        plugin_base   = RAILS_ROOT + "/vendor/plugins/#{plugin}"

        options       = []

        files         = Rake::FileList.new

        options << "-o doc/plugins/#{plugin}"

        options << "--title '#{plugin.titlecase} Plugin Documentation'"

        options << '--line-numbers' << '--inline-source'

        options << '-T html'

        # Include every file in the plugin's load_paths (see Plugin#load_paths)

        if Engines.plugins[plugin]

          files.include("#{plugin_base}/{#{Engines.plugins[plugin].load_paths.join(",")}}/**/*.rb")

        end

        if File.exists?("#{plugin_base}/README")

          files.include("#{plugin_base}/README")    

          options << "--main '#{plugin_base}/README'"

        end

        files.include("#{plugin_base}/CHANGELOG") if File.exists?("#{plugin_base}/CHANGELOG")

        if files.empty?

          puts "No source files found in #{plugin_base}. No documentation will be generated."

        else

          options << files.to_s

          sh %(rdoc #{options * ' '})

        end

      end

    end

  end

end

namespace :test do

  task :warn_about_multiple_plugin_testing_with_engines do

    puts %{-~============== A Moste Polite Warninge ===========================~-

You may experience issues testing multiple plugins at once when using

the code-mixing features that the engines plugin provides. If you do

experience any problems, please test plugins individually, i.e.

  $ rake test:plugins PLUGIN=my_plugin

or use the per-type plugin test tasks:

  $ rake test:plugins:units

  $ rake test:plugins:functionals

  $ rake test:plugins:integration

  $ rake test:plugins:all

Report any issues on http://dev.rails-engines.org. Thanks!

-~===============( ... as you were ... )============================~-}

  end

  namespace :engines do

    def engine_plugins

      Dir["vendor/plugins/*"].select { |f| File.directory?(File.join(f, "app")) }.map { |f| File.basename(f) }.join(",")

    end

    desc "Run tests from within engines plugins (plugins with an 'app' directory)"

    task :all => [:units, :functionals, :integration]

    desc "Run unit tests from within engines plugins (plugins with an 'app' directory)"

    Rake::TestTask.new(:units => "test:plugins:setup_plugin_fixtures") do |t|

      t.pattern = "vendor/plugins/{#{ENV['PLUGIN'] || engine_plugins}}/test/unit/**/*_test.rb"

      t.verbose = true

    end

    desc "Run functional tests from within engines plugins (plugins with an 'app' directory)"

    Rake::TestTask.new(:functionals => "test:plugins:setup_plugin_fixtures") do |t|

      t.pattern = "vendor/plugins/{#{ENV['PLUGIN'] || engine_plugins}}/test/functional/**/*_test.rb"

      t.verbose = true

    end

    desc "Run integration tests from within engines plugins (plugins with an 'app' directory)"

    Rake::TestTask.new(:integration => "test:plugins:setup_plugin_fixtures") do |t|

      t.pattern = "vendor/plugins/{#{ENV['PLUGIN'] || engine_plugins}}/test/integration/**/*_test.rb"

      t.verbose = true

    end

  end

  namespace :plugins do

    desc "Run the plugin tests in vendor/plugins/**/test (or specify with PLUGIN=name)"

    task :all => [:warn_about_multiple_plugin_testing_with_engines, 

                  :units, :functionals, :integration]

    desc "Run all plugin unit tests"

    Rake::TestTask.new(:units => :setup_plugin_fixtures) do |t|

      t.pattern = "vendor/plugins/#{ENV['PLUGIN'] || "**"}/test/unit/**/*_test.rb"

      t.verbose = true

    end

    desc "Run all plugin functional tests"

    Rake::TestTask.new(:functionals => :setup_plugin_fixtures) do |t|

      t.pattern = "vendor/plugins/#{ENV['PLUGIN'] || "**"}/test/functional/**/*_test.rb"

      t.verbose = true

    end

    desc "Integration test engines"

    Rake::TestTask.new(:integration => :setup_plugin_fixtures) do |t|

      t.pattern = "vendor/plugins/#{ENV['PLUGIN'] || "**"}/test/integration/**/*_test.rb"

      t.verbose = true

    end

    desc "Mirrors plugin fixtures into a single location to help plugin tests"

    task :setup_plugin_fixtures => :environment do

      Engines::Testing.setup_plugin_fixtures

    end

    # Patch the default plugin testing task to have setup_plugin_fixtures as a prerequisite

    Rake::Task["test:plugins"].prerequisites << "test:plugins:setup_plugin_fixtures"

  end

end