# frozen_string_literal: true

# Redmine - project management software
# Copyright (C) 2006-2021  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 IssueTest < ActiveSupport::TestCase
  fixtures :projects, :users, :email_addresses, :user_preferences, :members, :member_roles, :roles,
           :groups_users,
           :trackers, :projects_trackers,
           :enabled_modules,
           :versions,
           :issue_statuses, :issue_categories, :issue_relations, :workflows,
           :enumerations,
           :issues, :journals, :journal_details,
           :watchers,
           :custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,
           :time_entries

  include Redmine::I18n

  def setup
    User.current = nil
    set_language_if_valid 'en'
  end

  def teardown
    User.current = nil
  end

  def test_initialize
    issue = Issue.new

    assert_nil issue.project_id
    assert_nil issue.tracker_id
    assert_nil issue.status_id
    assert_nil issue.author_id
    assert_nil issue.assigned_to_id
    assert_nil issue.category_id

    assert_equal IssuePriority.default, issue.priority
  end

  def test_create
    issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                      :status_id => 1, :priority => IssuePriority.all.first,
                      :subject => 'test_create',
                      :description => 'IssueTest#test_create', :estimated_hours => '1:30')
    assert issue.save
    issue.reload
    assert_equal 1.5, issue.estimated_hours
  end

  def test_create_minimal
    issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :subject => 'test_create')
    assert issue.save
    assert_equal issue.tracker.default_status, issue.status
    assert issue.description.nil?
    assert_nil issue.estimated_hours
  end

  def test_create_with_all_fields_disabled
    tracker = Tracker.find(1)
    tracker.core_fields = []
    tracker.save!

    issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :subject => 'test_create_with_all_fields_disabled')
    assert_save issue
  end

  def test_start_date_format_should_be_validated
    set_language_if_valid 'en'
    ['2012', 'ABC', '2012-15-20'].each do |invalid_date|
      issue = Issue.new(:start_date => invalid_date)
      assert !issue.valid?
      assert_include 'Start date is not a valid date', issue.errors.full_messages, "No error found for invalid date #{invalid_date}"
    end
  end

  def test_due_date_format_should_be_validated
    set_language_if_valid 'en'
    ['2012', 'ABC', '2012-15-20'].each do |invalid_date|
      issue = Issue.new(:due_date => invalid_date)
      assert !issue.valid?
      assert_include 'Due date is not a valid date', issue.errors.full_messages, "No error found for invalid date #{invalid_date}"
    end
  end

  def test_due_date_lesser_than_start_date_should_not_validate
    set_language_if_valid 'en'
    issue = Issue.new(:start_date => '2012-10-06', :due_date => '2012-10-02')
    assert !issue.valid?
    assert_include 'Due date must be greater than start date', issue.errors.full_messages
  end

  def test_start_date_lesser_than_soonest_start_should_not_validate_on_create
    issue = Issue.generate(:start_date => '2013-06-04')
    issue.stubs(:soonest_start).returns(Date.parse('2013-06-10'))
    assert !issue.valid?
    assert_include "Start date cannot be earlier than 06/10/2013 because of preceding issues", issue.errors.full_messages
  end

  def test_start_date_lesser_than_soonest_start_should_not_validate_on_update_if_changed
    issue = Issue.generate!(:start_date => '2013-06-04')
    issue.stubs(:soonest_start).returns(Date.parse('2013-06-10'))
    issue.start_date = '2013-06-07'
    assert !issue.valid?
    assert_include "Start date cannot be earlier than 06/10/2013 because of preceding issues", issue.errors.full_messages
  end

  def test_start_date_lesser_than_soonest_start_should_validate_on_update_if_unchanged
    issue = Issue.generate!(:start_date => '2013-06-04')
    issue.stubs(:soonest_start).returns(Date.parse('2013-06-10'))
    assert issue.valid?
  end

  def test_estimated_hours_should_be_validated
    set_language_if_valid 'en'
    ['-2', '123abc'].each do |invalid|
      issue = Issue.new(:estimated_hours => invalid)
      assert !issue.valid?
      assert_include 'Estimated time is invalid', issue.errors.full_messages
    end
  end

  def test_create_with_required_custom_field
    set_language_if_valid 'en'
    field = IssueCustomField.find_by_name('Database')
    field.update!(:is_required => true)

    issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                      :status_id => 1, :subject => 'test_create',
                      :description => 'IssueTest#test_create_with_required_custom_field')
    assert issue.available_custom_fields.include?(field)
    # No value for the custom field
    assert !issue.save
    assert_equal ["Database cannot be blank"], issue.errors.full_messages
    # Blank value
    issue.custom_field_values = {field.id => ''}
    assert !issue.save
    assert_equal ["Database cannot be blank"], issue.errors.full_messages
    # Invalid value
    issue.custom_field_values = {field.id => 'SQLServer'}
    assert !issue.save
    assert_equal ["Database is not included in the list"], issue.errors.full_messages
    # Valid value
    issue.custom_field_values = {field.id => 'PostgreSQL'}
    assert issue.save
    issue.reload
    assert_equal 'PostgreSQL', issue.custom_value_for(field).value
  end

  def test_create_with_group_assignment
    with_settings :issue_group_assignment => '1' do
      assert Issue.new(:project_id => 2, :tracker_id => 1, :author_id => 1,
                       :subject => 'Group assignment',
                       :assigned_to_id => 11).save
      issue = Issue.order('id DESC').first
      assert_kind_of Group, issue.assigned_to
      assert_equal Group.find(11), issue.assigned_to
    end
  end

  def test_create_with_parent_issue_id
    issue = Issue.new(:project_id => 1, :tracker_id => 1,
                      :author_id => 1, :subject => 'Group assignment',
                      :parent_issue_id => 1)
    assert_save issue
    assert_equal 1, issue.parent_issue_id
    assert_equal Issue.find(1), issue.parent
  end

  def test_create_with_sharp_parent_issue_id
    issue = Issue.new(:project_id => 1, :tracker_id => 1,
                      :author_id => 1, :subject => 'Group assignment',
                      :parent_issue_id => "#1")
    assert_save issue
    assert_equal 1, issue.parent_issue_id
    assert_equal Issue.find(1), issue.parent
  end

  def test_create_with_invalid_parent_issue_id
    set_language_if_valid 'en'
    issue = Issue.new(:project_id => 1, :tracker_id => 1,
                      :author_id => 1, :subject => 'Group assignment',
                      :parent_issue_id => '01ABC')
    assert !issue.save
    assert_equal '01ABC', issue.parent_issue_id
    assert_include 'Parent task is invalid', issue.errors.full_messages
  end

  def test_create_with_invalid_sharp_parent_issue_id
    set_language_if_valid 'en'
    issue = Issue.new(:project_id => 1, :tracker_id => 1,
                      :author_id => 1, :subject => 'Group assignment',
                      :parent_issue_id => '#01ABC')
    assert !issue.save
    assert_equal '#01ABC', issue.parent_issue_id
    assert_include 'Parent task is invalid', issue.errors.full_messages
  end

  def assert_visibility_match(user, issues)
    assert_equal issues.collect(&:id).sort, Issue.all.select {|issue| issue.visible?(user)}.collect(&:id).sort
  end

  def test_create_with_emoji_character
    skip if Redmine::Database.mysql? && !is_mysql_utf8mb4

    set_language_if_valid 'en'
    issue = Issue.new(:project_id => 1, :tracker_id => 1,
                      :author_id => 1, :subject => 'Group assignment',
                      :description => 'Hello 😀')
    assert issue.save
    assert_equal 'Hello 😀', issue.description
  end

  def test_visible_scope_for_anonymous
    # Anonymous user should see issues of public projects only
    issues = Issue.visible(User.anonymous).to_a
    assert issues.any?
    assert_nil issues.detect {|issue| !issue.project.is_public?}
    assert_nil issues.detect {|issue| issue.is_private?}
    assert_visibility_match User.anonymous, issues
  end

  def test_visible_scope_for_anonymous_without_view_issues_permissions
    # Anonymous user should not see issues without permission
    Role.anonymous.remove_permission!(:view_issues)
    issues = Issue.visible(User.anonymous).to_a
    assert issues.empty?
    assert_visibility_match User.anonymous, issues
  end

  def test_visible_scope_for_anonymous_without_view_issues_permissions_and_membership
    Role.anonymous.remove_permission!(:view_issues)
    Member.create!(:project_id => 1, :principal => Group.anonymous, :role_ids => [2])

    issues = Issue.visible(User.anonymous).all
    assert issues.any?
    assert_equal [1], issues.map(&:project_id).uniq.sort
    assert_visibility_match User.anonymous, issues
  end

  def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_default
    Role.anonymous.update!(:issues_visibility => 'default')
    issue = Issue.generate!(:author => User.anonymous, :is_private => true)
    assert_not Issue.where(:id => issue.id).visible(User.anonymous).exists?
    assert !issue.visible?(User.anonymous)
  end

  def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_own
    assert Role.anonymous.update!(:issues_visibility => 'own')
    issue = Issue.generate!(:author => User.anonymous, :is_private => true)
    assert_not Issue.where(:id => issue.id).visible(User.anonymous).exists?
    assert !issue.visible?(User.anonymous)
  end

  def test_visible_scope_for_non_member
    user = User.find(9)
    assert user.projects.empty?
    # Non member user should see issues of public projects only
    issues = Issue.visible(user).to_a
    assert issues.any?
    assert_nil issues.detect {|issue| !issue.project.is_public?}
    assert_nil issues.detect {|issue| issue.is_private?}
    assert_visibility_match user, issues
  end

  def test_visible_scope_for_non_member_with_own_issues_visibility
    Role.non_member.update! :issues_visibility => 'own'
    Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 9, :subject => 'Issue by non member')
    user = User.find(9)

    issues = Issue.visible(user).to_a
    assert issues.any?
    assert_nil issues.detect {|issue| issue.author != user}
    assert_visibility_match user, issues
  end

  def test_visible_scope_for_non_member_without_view_issues_permissions
    # Non member user should not see issues without permission
    Role.non_member.remove_permission!(:view_issues)
    user = User.find(9)
    assert user.projects.empty?
    issues = Issue.visible(user).to_a
    assert issues.empty?
    assert_visibility_match user, issues
  end

  def test_visible_scope_for_non_member_without_view_issues_permissions_and_membership
    Role.non_member.remove_permission!(:view_issues)
    Member.create!(:project_id => 1, :principal => Group.non_member, :role_ids => [2])
    user = User.find(9)

    issues = Issue.visible(user).all
    assert issues.any?
    assert_equal [1], issues.map(&:project_id).uniq.sort
    assert_visibility_match user, issues
  end

  def test_visible_scope_for_member
    user = User.find(9)
    # User should see issues of projects for which user has view_issues permissions only
    Role.non_member.remove_permission!(:view_issues)
    Member.create!(:principal => user, :project_id => 3, :role_ids => [2])
    issues = Issue.visible(user).to_a
    assert issues.any?
    assert_nil issues.detect {|issue| issue.project_id != 3}
    assert_nil issues.detect {|issue| issue.is_private?}
    assert_visibility_match user, issues
  end

  def test_visible_scope_for_member_without_view_issues_permission_and_non_member_role_having_the_permission
    Role.non_member.add_permission!(:view_issues)
    Role.find(1).remove_permission!(:view_issues)
    user = User.find(2)

    assert_equal 0, Issue.where(:project_id => 1).visible(user).count
    assert_equal false, Issue.where(:project_id => 1).first.visible?(user)
  end

  def test_visible_scope_with_custom_non_member_role_having_restricted_permission
    role = Role.generate!(:permissions => [:view_project])
    assert Role.non_member.has_permission?(:view_issues)
    user = User.generate!
    Member.create!(:principal => Group.non_member, :project_id => 1, :roles => [role])

    issues = Issue.visible(user).to_a
    assert issues.any?
    assert_nil issues.detect {|issue| issue.project_id == 1}
  end

  def test_visible_scope_with_custom_non_member_role_having_extended_permission
    role = Role.generate!(:permissions => [:view_project, :view_issues])
    Role.non_member.remove_permission!(:view_issues)
    user = User.generate!
    Member.create!(:principal => Group.non_member, :project_id => 1, :roles => [role])

    issues = Issue.visible(user).to_a
    assert issues.any?
    assert_not_nil issues.detect {|issue| issue.project_id == 1}
  end

  def test_visible_scope_for_member_with_groups_should_return_assigned_issues
    user = User.find(8)
    assert user.groups.any?
    group = user.groups.first
    Member.create!(:principal => group, :project_id => 1, :role_ids => [2])
    Role.non_member.remove_permission!(:view_issues)

    with_settings :issue_group_assignment => '1' do
      issue = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 3,
        :status_id => 1, :priority => IssuePriority.all.first,
        :subject => 'Assignment test',
        :assigned_to => group,
        :is_private => true)

      Role.find(2).update! :issues_visibility => 'default'
      issues = Issue.visible(User.find(8)).to_a
      assert issues.any?
      assert issues.include?(issue)

      Role.find(2).update! :issues_visibility => 'own'
      issues = Issue.visible(User.find(8)).to_a
      assert issues.any?
      assert_include issue, issues
    end
  end

  def test_visible_scope_for_member_with_limited_tracker_ids
    role = Role.find(1)
    role.set_permission_trackers :view_issues, [2]
    role.save!
    user = User.find(2)

    issues = Issue.where(:project_id => 1).visible(user).to_a
    assert issues.any?
    assert_equal [2], issues.map(&:tracker_id).uniq

    assert Issue.where(:project_id => 1).all? {|issue| issue.visible?(user) ^ issue.tracker_id != 2}
  end

  def test_visible_scope_should_consider_tracker_ids_on_each_project
    user = User.generate!

    project1 = Project.generate!
    role1 = Role.generate!
    role1.add_permission! :view_issues
    role1.set_permission_trackers :view_issues, :all
    role1.save!
    User.add_to_project(user, project1, role1)

    project2 = Project.generate!
    role2 = Role.generate!
    role2.add_permission! :view_issues
    role2.set_permission_trackers :view_issues, [2]
    role2.save!
    User.add_to_project(user, project2, role2)

    visible_issues = [
      Issue.generate!(:project => project1, :tracker_id => 1),
      Issue.generate!(:project => project1, :tracker_id => 2),
      Issue.generate!(:project => project2, :tracker_id => 2)
    ]
    hidden_issue = Issue.generate!(:project => project2, :tracker_id => 1)

    issues = Issue.where(:project_id => [project1.id, project2.id]).visible(user)
    assert_equal visible_issues.map(&:id), issues.ids.sort

    assert visible_issues.all? {|issue| issue.visible?(user)}
    assert !hidden_issue.visible?(user)
  end

  def test_visible_scope_should_not_consider_roles_without_view_issues_permission
    user = User.generate!
    role1 = Role.generate!
    role1.remove_permission! :view_issues
    role1.set_permission_trackers :view_issues, :all
    role1.save!
    role2 = Role.generate!
    role2.add_permission! :view_issues
    role2.set_permission_trackers :view_issues, [2]
    role2.save!
    User.add_to_project(user, Project.find(1), [role1, role2])

    issues = Issue.where(:project_id => 1).visible(user).to_a
    assert issues.any?
    assert_equal [2], issues.map(&:tracker_id).uniq

    assert Issue.where(:project_id => 1).all? {|issue| issue.visible?(user) ^ issue.tracker_id != 2}
  end

  def test_visible_scope_for_admin
    user = User.find(1)
    user.members.each(&:destroy)
    assert user.projects.empty?
    issues = Issue.visible(user).to_a
    assert issues.any?
    # Admin should see issues on private projects that admin does not belong to
    assert issues.detect {|issue| !issue.project.is_public?}
    # Admin should see private issues of other users
    assert issues.detect {|issue| issue.is_private? && issue.author != user}
    assert_visibility_match user, issues
  end

  def test_visible_scope_with_project
    project = Project.find(1)
    issues = Issue.visible(User.find(2), :project => project).to_a
    projects = issues.collect(&:project).uniq
    assert_equal 1, projects.size
    assert_equal project, projects.first
  end

  def test_visible_scope_with_project_and_subprojects
    project = Project.find(1)
    issues = Issue.visible(User.find(2), :project => project, :with_subprojects => true).to_a
    projects = issues.collect(&:project).uniq
    assert projects.size > 1
    assert_equal [], projects.select {|p| !p.is_or_is_descendant_of?(project)}
  end

  def test_visible_and_nested_set_scopes
    user = User.generate!
    Member.create!(:project_id => 1, :principal => user, :role_ids => [1])
    parent = Issue.generate!(:assigned_to => user)
    assert parent.visible?(user)
    child1 = Issue.generate!(:parent_issue_id => parent.id, :assigned_to => user)
    child2 = Issue.generate!(:parent_issue_id => parent.id, :assigned_to => user)
    parent.reload
    child1.reload
    child2.reload
    assert child1.visible?(user)
    assert child2.visible?(user)
    assert_equal 2, parent.descendants.count
    assert_equal 2, parent.descendants.visible(user).count
    # awesome_nested_set 2-1-stable branch has regression.
    # https://github.com/collectiveidea/awesome_nested_set/commit/3d5ac746542b564f6586c2316180254b088bebb6
    # ActiveRecord::StatementInvalid: SQLite3::SQLException: ambiguous column name: lft:
    assert_equal 2, parent.descendants.collect{|i| i}.size
    assert_equal 2, parent.descendants.visible(user).collect{|i| i}.size
  end

  def test_visible_scope_with_unsaved_user_should_not_raise_an_error
    user = User.new
    assert_nothing_raised do
      Issue.visible(user).to_a
    end
  end

  def test_open_scope
    issues = Issue.open.to_a
    assert_nil issues.detect(&:closed?)
  end

  def test_open_scope_with_arg
    issues = Issue.open(false).to_a
    assert_equal issues, issues.select(&:closed?)
  end

  def test_fixed_version_scope_with_a_version_should_return_its_fixed_issues
    version = Version.find(2)
    assert version.fixed_issues.any?
    assert_equal version.fixed_issues.to_a.sort, Issue.fixed_version(version).to_a.sort
  end

  def test_fixed_version_scope_with_empty_array_should_return_no_result
    assert_equal 0, Issue.fixed_version([]).count
  end

  def test_assigned_to_scope_should_return_issues_assigned_to_the_user
    user = User.generate!
    issue = Issue.generate!
    Issue.where(:id => issue.id).update_all :assigned_to_id => user.id
    assert_equal [issue], Issue.assigned_to(user).to_a
  end

  def test_assigned_to_scope_should_return_issues_assigned_to_the_user_groups
    group = Group.generate!
    user = User.generate!
    group.users << user
    issue = Issue.generate!
    Issue.where(:id => issue.id).update_all :assigned_to_id => group.id
    assert_equal [issue], Issue.assigned_to(user).to_a
  end

  def test_issue_should_be_readonly_on_closed_project
    issue = Issue.find(1)
    user = User.find(1)

    assert_equal true, issue.visible?(user)
    assert_equal true, issue.editable?(user)
    assert_equal true, issue.deletable?(user)

    issue.project.close
    issue.reload

    assert_equal true, issue.visible?(user)
    assert_equal false, issue.editable?(user)
    assert_equal false, issue.deletable?(user)
  end

  def test_issue_should_editable_by_author
    Role.all.each do |r|
      r.remove_permission! :edit_issues
      r.add_permission! :edit_own_issues
    end

    issue = Issue.find(1)
    user = User.find_by_login('jsmith')

    # author
    assert_equal user, issue.author
    assert_equal true, issue.attributes_editable?(user)

    # not author
    assert_equal false, issue.attributes_editable?(User.find_by_login('dlopper'))
  end

  def test_errors_full_messages_should_include_custom_fields_errors
    field = IssueCustomField.find_by_name('Database')

    issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                      :status_id => 1, :subject => 'test_create',
                      :description => 'IssueTest#test_create_with_required_custom_field')
    assert issue.available_custom_fields.include?(field)
    # Invalid value
    issue.custom_field_values = {field.id => 'SQLServer'}

    assert !issue.valid?
    assert_equal 1, issue.errors.full_messages.size
    assert_equal "Database #{I18n.translate('activerecord.errors.messages.inclusion')}",
                 issue.errors.full_messages.first
  end

  def test_update_issue_with_required_custom_field
    field = IssueCustomField.find_by_name('Database')
    field.update!(:is_required => true)

    issue = Issue.find(1)
    assert_nil issue.custom_value_for(field)
    assert issue.available_custom_fields.include?(field)
    # No change to custom values, issue can be saved
    assert issue.save
    # Blank value
    issue.custom_field_values = {field.id => ''}
    assert !issue.save
    # Valid value
    issue.custom_field_values = {field.id => 'PostgreSQL'}
    assert issue.save
    issue.reload
    assert_equal 'PostgreSQL', issue.custom_value_for(field).value
  end

  def test_should_not_update_attributes_if_custom_fields_validation_fails
    issue = Issue.find(1)
    field = IssueCustomField.find_by_name('Database')
    assert issue.available_custom_fields.include?(field)

    issue.custom_field_values = {field.id => 'Invalid'}
    issue.subject = 'Should be not be saved'
    assert !issue.save

    issue.reload
    assert_equal "Cannot print recipes", issue.subject
  end

  def test_should_not_recreate_custom_values_objects_on_update
    field = IssueCustomField.find_by_name('Database')

    issue = Issue.find(1)
    issue.custom_field_values = {field.id => 'PostgreSQL'}
    assert issue.save
    custom_value = issue.custom_value_for(field)
    issue.reload
    issue.custom_field_values = {field.id => 'MySQL'}
    assert issue.save
    issue.reload
    assert_equal custom_value.id, issue.custom_value_for(field).id
  end

  def test_setting_project_should_set_version_to_default_version
    version = Version.generate!(:project_id => 1)
    Project.find(1).update!(:default_version_id => version.id)

    issue = Issue.new(:project_id => 1)
    assert_equal version, issue.fixed_version
  end

  def test_default_assigned_to_based_on_category_should_be_set_on_create
    user = User.find(3)
    category = IssueCategory.create!(:project_id => 1, :name => 'With default assignee', :assigned_to_id => 3)

    issue = Issue.generate!(:project_id => 1, :category_id => category.id)
    assert_equal user, issue.assigned_to
  end

  def test_default_assigned_to_based_on_project_should_be_set_on_create
    user = User.find(3)
    Project.find(1).update!(:default_assigned_to_id => user.id)

    issue = Issue.generate!(:project_id => 1)
    assert_equal user, issue.assigned_to
  end

  def test_default_assigned_to_with_required_assignee_should_validate
    category = IssueCategory.create!(:project_id => 1, :name => 'With default assignee', :assigned_to_id => 3)
    Issue.any_instance.stubs(:required_attribute_names).returns(['assigned_to_id'])

    issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :subject => 'Default')
    assert !issue.save
    assert issue.errors['assigned_to_id'].present?

    issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :subject => 'Default', :category_id => category.id)
    assert_save issue
  end

  def test_should_not_update_custom_fields_on_changing_tracker_with_different_custom_fields
    issue = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1,
                          :status_id => 1, :subject => 'Test',
                          :custom_field_values => {'2' => 'Test'})
    assert !Tracker.find(2).custom_field_ids.include?(2)

    issue = Issue.find(issue.id)
    issue.attributes = {:tracker_id => 2, :custom_field_values => {'1' => ''}}

    issue = Issue.find(issue.id)
    custom_value = issue.custom_value_for(2)
    assert_not_nil custom_value
    assert_equal 'Test', custom_value.value
  end

  def test_assigning_tracker_id_should_reload_custom_fields_values
    issue = Issue.new(:project => Project.find(1))
    assert issue.custom_field_values.empty?
    issue.tracker_id = 1
    assert issue.custom_field_values.any?
  end

  def test_assigning_attributes_should_assign_project_and_tracker_first
    seq = sequence('seq')
    issue = Issue.new
    issue.expects(:project_id=).in_sequence(seq)
    issue.expects(:tracker_id=).in_sequence(seq)
    issue.expects(:subject=).in_sequence(seq)
    assert_raise Exception do
      issue.attributes = {:subject => 'Test'}
    end
    assert_nothing_raised do
      issue.attributes = {:tracker_id => 2, :project_id => 1, :subject => 'Test'}
    end
  end

  def test_assigning_tracker_and_custom_fields_should_assign_custom_fields
    attributes = ActiveSupport::OrderedHash.new
    attributes['custom_field_values'] = {'1' => 'MySQL'}
    attributes['tracker_id'] = '1'
    issue = Issue.new(:project => Project.find(1))
    issue.attributes = attributes
    assert_equal 'MySQL', issue.custom_field_value(1)
  end

  def test_changing_tracker_should_clear_disabled_core_fields
    tracker = Tracker.find(2)
    tracker.core_fields = tracker.core_fields - %w(due_date)
    tracker.save!

    issue = Issue.generate!(:tracker_id => 1, :start_date => Date.today, :due_date => Date.today)
    issue.save!

    issue.tracker_id = 2
    issue.save!
    assert_not_nil issue.start_date
    assert_nil issue.due_date
  end

  def test_attribute_cleared_on_tracker_change_should_be_journalized
    CustomField.delete_all
    tracker = Tracker.find(2)
    tracker.core_fields = tracker.core_fields - %w(due_date)
    tracker.save!

    issue = Issue.generate!(:tracker_id => 1, :due_date => Date.today)
    issue.save!

    assert_difference 'Journal.count' do
      issue.init_journal User.find(1)
      issue.tracker_id = 2
      issue.save!
      assert_nil issue.due_date
    end
    journal = Journal.order('id DESC').first
    details = journal.details.select {|d| d.prop_key == 'due_date'}
    assert_equal 1, details.count
  end

  def test_reload_should_reload_custom_field_values
    issue = Issue.generate!
    issue.custom_field_values = {'2' => 'Foo'}
    issue.save!

    issue = Issue.order('id desc').first
    assert_equal 'Foo', issue.custom_field_value(2)

    issue.custom_field_values = {'2' => 'Bar'}
    assert_equal 'Bar', issue.custom_field_value(2)

    issue.reload
    assert_equal 'Foo', issue.custom_field_value(2)
  end

  def test_should_update_issue_with_disabled_tracker
    p = Project.find(1)
    issue = Issue.find(1)

    p.trackers.delete(issue.tracker)
    assert !p.trackers.include?(issue.tracker)

    issue.reload
    issue.subject = 'New subject'
    assert issue.save
  end

  def test_should_not_set_a_disabled_tracker
    p = Project.find(1)
    p.trackers.delete(Tracker.find(2))

    issue = Issue.find(1)
    issue.tracker_id = 2
    issue.subject = 'New subject'
    assert !issue.save
    assert_not_equal [], issue.errors[:tracker_id]
  end

  def test_category_based_assignment
    issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3,
                         :status_id => 1, :priority => IssuePriority.all.first,
                         :subject => 'Assignment test',
                         :description => 'Assignment test', :category_id => 1)
    assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to
  end

  def test_new_statuses_allowed_to
    WorkflowTransition.delete_all
    WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                               :old_status_id => 1, :new_status_id => 2,
                               :author => false, :assignee => false)
    WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                               :old_status_id => 1, :new_status_id => 3,
                               :author => true, :assignee => false)
    WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                               :old_status_id => 1, :new_status_id => 4,
                               :author => false, :assignee => true)
    WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                               :old_status_id => 1, :new_status_id => 5,
                               :author => true, :assignee => true)
    status = IssueStatus.find(1)
    role = Role.find(1)
    tracker = Tracker.find(1)
    user = User.find(2)

    issue = Issue.generate!(:tracker => tracker, :status => status,
                            :project_id => 1, :author_id => 1)
    assert_equal [1, 2], issue.new_statuses_allowed_to(user).map(&:id)

    issue = Issue.generate!(:tracker => tracker, :status => status,
                            :project_id => 1, :author => user)
    assert_equal [1, 2, 3, 5], issue.new_statuses_allowed_to(user).map(&:id)

    issue = Issue.generate!(:tracker => tracker, :status => status,
                            :project_id => 1, :author_id => 1,
                            :assigned_to => user)
    assert_equal [1, 2, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)

    issue = Issue.generate!(:tracker => tracker, :status => status,
                            :project_id => 1, :author => user,
                            :assigned_to => user)
    assert_equal [1, 2, 3, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)
  end

  def test_new_statuses_allowed_to_should_consider_group_assignment
    WorkflowTransition.delete_all
    WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                               :old_status_id => 1, :new_status_id => 4,
                               :author => false, :assignee => true)
    group = Group.generate!
    Member.create!(:project_id => 1, :principal => group, :role_ids => [1])

    user = User.find(2)
    group.users << user

    with_settings :issue_group_assignment => '1' do
      issue = Issue.generate!(:author_id => 1, :assigned_to => group)
      assert_include 4, issue.new_statuses_allowed_to(user).map(&:id)
    end
  end

  def test_new_statuses_allowed_to_should_return_all_transitions_for_admin
    admin = User.find(1)
    issue = Issue.find(1)
    assert !admin.member_of?(issue.project)
    expected_statuses = [issue.status] +
                            WorkflowTransition.where(:old_status_id => issue.status_id).
                                map(&:new_status).uniq.sort
    assert_equal expected_statuses, issue.new_statuses_allowed_to(admin)
  end

  def test_new_statuses_allowed_to_should_return_allowed_statuses_when_copying
    Tracker.find(1).generate_transitions! :role_id => 1, :clear => true, 0 => [1, 3]

    orig = Issue.generate!(:project_id => 1, :tracker_id => 1, :status_id => 4)
    issue = orig.copy
    assert_equal [1, 3], issue.new_statuses_allowed_to(User.find(2)).map(&:id)
    assert_equal 1, issue.status_id
  end

  def test_safe_attributes_names_should_be_updated_when_changing_project
    issue = Issue.new
    with_current_user(User.find(2)) do
      assert_not_include 'watcher_user_ids', issue.safe_attribute_names

      issue.project_id = 1
      assert_include 'watcher_user_ids', issue.safe_attribute_names
    end
  end

  def test_safe_attributes_names_should_not_include_disabled_field
    tracker = Tracker.new(:core_fields => %w(assigned_to_id fixed_version_id))

    issue = Issue.new(:tracker => tracker)
    assert_include 'tracker_id', issue.safe_attribute_names
    assert_include 'status_id', issue.safe_attribute_names
    assert_include 'subject', issue.safe_attribute_names
    assert_include 'custom_field_values', issue.safe_attribute_names
    assert_include 'custom_fields', issue.safe_attribute_names
    assert_include 'lock_version', issue.safe_attribute_names

    tracker.core_fields.each do |field|
      assert_include field, issue.safe_attribute_names
    end

    tracker.disabled_core_fields.each do |field|
      assert_not_include field, issue.safe_attribute_names
    end
  end

  def test_safe_attributes_should_ignore_disabled_fields
    tracker = Tracker.find(1)
    tracker.core_fields = %w(assigned_to_id due_date)
    tracker.save!

    issue = Issue.new(:tracker => tracker)
    issue.safe_attributes = {'start_date' => '2012-07-14', 'due_date' => '2012-07-14'}
    assert_nil issue.start_date
    assert_equal Date.parse('2012-07-14'), issue.due_date
  end

  def test_safe_attributes_notes_should_check_add_issue_notes_permission
    # With add_issue_notes permission
    user = User.find(2)
    issue = Issue.new(:project => Project.find(1))
    issue.init_journal(user)
    issue.send :safe_attributes=, {'notes' => 'note'}, user
    assert_equal 'note', issue.notes

    # Without add_issue_notes permission
    Role.find(1).remove_permission!(:add_issue_notes)
    issue = Issue.new(:project => Project.find(1))
    user.reload
    issue.init_journal(user)
    issue.send :safe_attributes=, {'notes' => 'note'}, user
    assert_equal '', issue.notes
  end

  def test_safe_attributes_should_accept_target_tracker_enabled_fields
    source = Tracker.find(1)
    source.core_fields = []
    source.save!
    target = Tracker.find(2)
    target.core_fields = %w(assigned_to_id due_date)
    target.save!
    user = User.find(2)

    issue = Issue.new(:project => Project.find(1), :tracker => source)
    issue.send :safe_attributes=, {'tracker_id' => 2, 'due_date' => '2012-07-14'}, user
    assert_equal target, issue.tracker
    assert_equal Date.parse('2012-07-14'), issue.due_date
  end

  def test_safe_attributes_should_not_include_readonly_fields
    WorkflowPermission.delete_all
    WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                               :role_id => 1, :field_name => 'due_date',
                               :rule => 'readonly')
    user = User.find(2)

    issue = Issue.new(:project_id => 1, :tracker_id => 1)
    assert_equal %w(due_date), issue.read_only_attribute_names(user)
    assert_not_include 'due_date', issue.safe_attribute_names(user)

    issue.send :safe_attributes=, {'start_date' => '2012-07-14', 'due_date' => '2012-07-14'}, user
    assert_equal Date.parse('2012-07-14'), issue.start_date
    assert_nil issue.due_date
  end

  def test_safe_attributes_should_not_include_readonly_custom_fields
    cf1 = IssueCustomField.create!(:name => 'Writable field',
                                   :field_format => 'string',
                                   :is_for_all => true, :tracker_ids => [1])
    cf2 = IssueCustomField.create!(:name => 'Readonly field',
                                   :field_format => 'string',
                                   :is_for_all => true, :tracker_ids => [1])
    WorkflowPermission.delete_all
    WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                               :role_id => 1, :field_name => cf2.id.to_s,
                               :rule => 'readonly')
    user = User.find(2)
    issue = Issue.new(:project_id => 1, :tracker_id => 1)
    assert_equal [cf2.id.to_s], issue.read_only_attribute_names(user)
    assert_not_include cf2.id.to_s, issue.safe_attribute_names(user)

    issue.send(
      :safe_attributes=,
      {
        'custom_field_values' =>
          {
            cf1.id.to_s => 'value1',
            cf2.id.to_s => 'value2'
          }
      },
      user
    )
    assert_equal 'value1', issue.custom_field_value(cf1)
    assert_nil issue.custom_field_value(cf2)

    issue.send(
      :safe_attributes=,
      {
        'custom_fields' =>
          [
            {'id' => cf1.id.to_s, 'value' => 'valuea'},
            {'id' => cf2.id.to_s, 'value' => 'valueb'}
          ]
      }, user
    )
    assert_equal 'valuea', issue.custom_field_value(cf1)
    assert_nil issue.custom_field_value(cf2)
  end

  def test_editable_custom_field_values_should_return_non_readonly_custom_values
    cf1 = IssueCustomField.create!(:name => 'Writable field', :field_format => 'string',
                                   :is_for_all => true, :tracker_ids => [1, 2])
    cf2 = IssueCustomField.create!(:name => 'Readonly field', :field_format => 'string',
                                   :is_for_all => true, :tracker_ids => [1, 2])
    WorkflowPermission.delete_all
    WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1,
                               :field_name => cf2.id.to_s, :rule => 'readonly')
    user = User.find(2)

    issue = Issue.new(:project_id => 1, :tracker_id => 1)
    values = issue.editable_custom_field_values(user)
    assert values.detect {|value| value.custom_field == cf1}
    assert_nil values.detect {|value| value.custom_field == cf2}

    issue.tracker_id = 2
    values = issue.editable_custom_field_values(user)
    assert values.detect {|value| value.custom_field == cf1}
    assert values.detect {|value| value.custom_field == cf2}
  end

  def test_editable_custom_fields_should_return_custom_field_that_is_enabled_for_the_role_only
    enabled_cf =
      IssueCustomField.generate!(:is_for_all => true, :tracker_ids => [1],
                                 :visible => false, :role_ids => [1, 2])
    disabled_cf =
      IssueCustomField.generate!(:is_for_all => true, :tracker_ids => [1],
                                 :visible => false, :role_ids => [2])
    user = User.find(2)
    issue = Issue.new(:project_id => 1, :tracker_id => 1)

    assert_include enabled_cf, issue.editable_custom_fields(user)
    assert_not_include disabled_cf, issue.editable_custom_fields(user)
  end

  def test_safe_attributes_should_accept_target_tracker_writable_fields
    WorkflowPermission.delete_all
    WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                               :role_id => 1, :field_name => 'due_date',
                               :rule => 'readonly')
    WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,
                               :role_id => 1, :field_name => 'start_date',
                               :rule => 'readonly')
    user = User.find(2)

    issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)

    issue.send :safe_attributes=, {'start_date' => '2012-07-12',
                                   'due_date' => '2012-07-14'}, user
    assert_equal Date.parse('2012-07-12'), issue.start_date
    assert_nil issue.due_date

    issue.send :safe_attributes=, {'start_date' => '2012-07-15',
                                   'due_date' => '2012-07-16',
                                   'tracker_id' => 2}, user
    assert_equal Date.parse('2012-07-12'), issue.start_date
    assert_equal Date.parse('2012-07-16'), issue.due_date
  end

  def test_safe_attributes_should_accept_target_status_writable_fields
    WorkflowPermission.delete_all
    WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                               :role_id => 1, :field_name => 'due_date',
                               :rule => 'readonly')
    WorkflowPermission.create!(:old_status_id => 2, :tracker_id => 1,
                               :role_id => 1, :field_name => 'start_date',
                               :rule => 'readonly')
    user = User.find(2)

    issue = Issue.new(:project_id => 1, :tracker_id =>pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
<?php
/**
 * @copyright Copyright (c) 2016, ownCloud, Inc.
 *
 * @author Adrian Brzezinski <adrian.brzezinski@eo.pl>
 * @author Jörn Friedrich Dreyer <jfd@butonic.de>
 * @author Morris Jobke <hey@morrisjobke.de>
 * @author Robin Appelman <robin@icewind.nl>
 * @author Roeland Jago Douma <roeland@famdouma.nl>
 *
 * @license AGPL-3.0
 *
 * This code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License, version 3,
 * as published by the Free Software Foundation.
 *
 * 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License, version 3,
 * along with this program. If not, see <http://www.gnu.org/licenses/>
 *
 */
namespace OC\Files\ObjectStore;

use GuzzleHttp\Client;
use GuzzleHttp\Exception\BadResponseException;
use GuzzleHttp\Psr7\Utils;
use Icewind\Streams\RetryWrapper;
use OCP\Files\NotFoundException;
use OCP\Files\ObjectStore\IObjectStore;
use OCP\Files\StorageAuthException;
use Psr\Log\LoggerInterface;

const SWIFT_SEGMENT_SIZE = 1073741824; // 1GB

class Swift implements IObjectStore {
	/**
	 * @var array
	 */
	private $params;

	/** @var SwiftFactory */
	private $swiftFactory;

	public function __construct($params, SwiftFactory $connectionFactory = null) {
		$this->swiftFactory = $connectionFactory ?: new SwiftFactory(
			\OC::$server->getMemCacheFactory()->createDistributed('swift::'),
			$params,
			\OC::$server->get(LoggerInterface::class)
		);
		$this->params = $params;
	}

	/**
	 * @return \OpenStack\ObjectStore\v1\Models\Container
	 * @throws StorageAuthException
	 * @throws \OCP\Files\StorageNotAvailableException
	 */
	private function getContainer() {
		return $this->swiftFactory->getContainer();
	}

	/**
	 * @return string the container name where objects are stored
	 */
	public function getStorageId() {
		if (isset($this->params['bucket'])) {
			return $this->params['bucket'];
		}

		return $this->params['container'];
	}

	public function writeObject($urn, $stream, string $mimetype = null) {
		$tmpFile = \OC::$server->getTempManager()->getTemporaryFile('swiftwrite');
		file_put_contents($tmpFile, $stream);
		$handle = fopen($tmpFile, 'rb');

		if (filesize($tmpFile) < SWIFT_SEGMENT_SIZE) {
			$this->getContainer()->createObject([
				'name' => $urn,
				'stream' => Utils::streamFor($handle),
				'contentType' => $mimetype,
			]);
		} else {
			$this->getContainer()->createLargeObject([
				'name' => $urn,
				'stream' => Utils::streamFor($handle),
				'segmentSize' => SWIFT_SEGMENT_SIZE,
				'contentType' => $mimetype,
			]);
		}
	}

	/**
	 * @param string $urn the unified resource name used to identify the object
	 * @return resource stream with the read data
	 * @throws \Exception from openstack or GuzzleHttp libs when something goes wrong
	 * @throws NotFoundException if file does not exist
	 */
	public function readObject($urn) {
		try {
			$publicUri = $this->getContainer()->getObject($urn)->getPublicUri();
			$tokenId = $this->swiftFactory->getCachedTokenId();

			$response = (new Client())->request('GET', $publicUri,
				[
					'stream' => true,
					'headers' => [
						'X-Auth-Token' => $tokenId,
						'Cache-Control' => 'no-cache',
					],
				]
			);
		} catch (BadResponseException $e) {
			if ($e->getResponse() && $e->getResponse()->getStatusCode() === 404) {
				throw new NotFoundException("object $urn not found in object store");
			} else {
				throw $e;
			}
		}

		return RetryWrapper::wrap($response->getBody()->detach());
	}

	/**
	 * @param string $urn Unified Resource Name
	 * @return void
	 * @throws \Exception from openstack lib when something goes wrong
	 */
	public function deleteObject($urn) {
		$this->getContainer()->getObject($urn)->delete();
	}

	/**
	 * @return void
	 * @throws \Exception from openstack lib when something goes wrong
	 */
	public function deleteContainer() {
		$this->getContainer()->delete();
	}

	public function objectExists($urn) {
		return $this->getContainer()->objectExists($urn);
	}

	public function copyObject($from, $to) {
		$this->getContainer()->getObject($from)->copy([
			'destination' => $this->getContainer()->name . '/' . $to
		]);
	}
}