show version on the UI when duplicating wps

Author: brunopagno

app/models/work_package/versions.rb

@@ -141,6 +141,19 @@ def assignable_versions(only_open: true)
   def override_target_versions? = !target_version_ids_replacements.nil?
   def override_observed_in_versions? = !observed_in_version_ids_replacements.nil?
 
+  # The target versions as they would be after saving: pending replacements
+  # (in their requested order) take precedence over the persisted association.
+  # The association itself only reflects replacements after
+  # #persist_version_associations ran, so anything rendering unsaved state
+  # (e.g. form payloads) has to read this instead.
+  def effective_target_versions
+    effective_versions(target_versions, target_version_ids_replacements)
+  end
+
+  def effective_observed_in_versions
+    effective_versions(observed_in_versions, observed_in_version_ids_replacements)
+  end
+
   # An override can also originate from the system, e.g. when versions that are
   # not shared with the (new) project are cleared on a project change. Such
   # overrides are marked here so that contracts don't attribute them to the
@@ -155,6 +168,13 @@ def system_version_override?(kind)
 
   private
 
+  def effective_versions(association, replacement_ids)
+    return association if replacement_ids.nil?
+
+    versions_by_id = Version.where(id: replacement_ids).index_by(&:id)
+    replacement_ids.filter_map { |id| versions_by_id[id] }
+  end
+
   def system_version_overrides
     @system_version_overrides ||= Set.new
   end

lib/api/v3/work_packages/work_package_representer.rb

@@ -584,6 +584,24 @@ def self_v3_path(*)
         associated_resources :target_versions,
                              v3_path: :version,
                              representer: ::API::V3::Versions::VersionRepresenter,
+                             getter: ->(*) {
+                               next unless embed_link?(:target_versions)
+
+                               represented.effective_target_versions.map do |version|
+                                 ::API::V3::Versions::VersionRepresenter.create(version, current_user:)
+                               end
+                             },
+                             link: ->(*) {
+                               represented.effective_target_versions.map do |version|
+                                 ::API::Decorators::LinkObject
+                                   .new(version,
+                                        property_name: :itself,
+                                        path: :version,
+                                        getter: :id,
+                                        title_attribute: :name)
+                                   .to_hash
+                               end
+                             },
                              setter: ->(fragment:, **) do
                                represented.target_version_ids = parse_link_ids_from_fragment(fragment, :version).compact
                              end

spec/lib/api/v3/work_packages/work_package_representer_spec.rb

@@ -744,6 +744,32 @@
             .at_path("_embedded/targetVersions/0/name")
         end
       end
+
+      context "when versions are assigned but not yet persisted" do
+        let!(:version) { create(:version, project: workspace) }
+        let!(:other_version) { create(:version, project: workspace) }
+
+        before do
+          work_package.target_version_ids_replacements = [other_version.id, version.id]
+        end
+
+        it "renders the pending versions in their requested order" do
+          expect(subject).to have_json_size(2).at_path("_links/targetVersions")
+          expect(subject)
+            .to be_json_eql(api_v3_paths.version(other_version.id).to_json)
+            .at_path("_links/targetVersions/0/href")
+          expect(subject)
+            .to be_json_eql(api_v3_paths.version(version.id).to_json)
+            .at_path("_links/targetVersions/1/href")
+        end
+
+        it "embeds the pending versions" do
+          expect(subject).to have_json_size(2).at_path("_embedded/targetVersions")
+          expect(subject)
+            .to be_json_eql(other_version.name.to_json)
+            .at_path("_embedded/targetVersions/0/name")
+        end
+      end
     end
 
     describe "project" do

spec/requests/api/v3/work_packages/create_form_resource_spec.rb

@@ -110,6 +110,41 @@
     end
   end
 
+  describe "with targetVersions (e.g. when duplicating a work package)" do
+    shared_let(:version) { create(:version, project:) }
+
+    let(:parameters) do
+      {
+        _links: {
+          project: {
+            href: "/api/v3/projects/#{project.id}"
+          },
+          version: {
+            href: api_v3_paths.version(version.id)
+          },
+          targetVersions: [
+            { href: api_v3_paths.version(version.id) }
+          ]
+        },
+        subject: "lorem ipsum"
+      }
+    end
+
+    it "has 0 validation errors" do
+      expect(subject.body).to have_json_size(0).at_path("_embedded/validationErrors")
+    end
+
+    it "echoes the versions in the payload although they are not persisted yet" do
+      expect(subject.body)
+        .to be_json_eql(api_v3_paths.version(version.id).to_json)
+        .at_path("_embedded/payload/_links/targetVersions/0/href")
+
+      expect(subject.body)
+        .to be_json_eql(api_v3_paths.version(version.id).to_json)
+        .at_path("_embedded/payload/_links/version/href")
+    end
+  end
+
   describe "custom fields" do
     context "when the custom field is required" do
       shared_let(:required_custom_field) do

spec/requests/api/v3/work_packages/form/work_package_form_resource_spec.rb

@@ -585,6 +585,29 @@
               end
             end
 
+            describe "targetVersions" do
+              let(:path) { "_embedded/payload/_links/targetVersions" }
+              let(:target_version) { create(:version, project:) }
+              let(:version_parameter) do
+                { _links: { targetVersions: [{ href: api_v3_paths.version(target_version.id) }] } }
+              end
+              let(:params) { valid_params.merge(version_parameter) }
+
+              context "for a valid version" do
+                include_context "with post request"
+
+                it_behaves_like "valid payload"
+
+                it_behaves_like "having no errors"
+
+                it "echoes the requested target versions although they are not persisted yet" do
+                  expect(subject.body)
+                    .to be_json_eql(api_v3_paths.version(target_version.id).to_json)
+                    .at_path("#{path}/0/href")
+                end
+              end
+            end
+
             describe "category" do
               let(:path) { "_embedded/payload/_links/category/href" }
               let(:links_path) { "_embedded/schema/category/_links" }