Implement MoveAttributeToHeader response mutator

Author: azimux

spec/foobara/command_connectors_http/move_attribute_to_header_spec.rb

@@ -0,0 +1,40 @@
+RSpec.describe Foobara::CommandConnectors::Http::MoveAttributeToHeader do
+  let(:command_class) do
+    stub_class(:SomeCommand, Foobara::Command) do
+      result foo: :string, bar: :string
+
+      def execute
+        { foo: "foo value", bar: "bar value" }
+      end
+    end
+  end
+
+  let(:response_mutator) do
+    described_class.for(:foo, "foo_header")
+  end
+
+  let(:command_connector) { Foobara::CommandConnectors::Http.new }
+  let(:response) { command_connector.run(path: "/run/#{command_class.full_command_name}") }
+
+  before do
+    command_connector.connect(command_class, response_mutators: response_mutator)
+  end
+
+  it "moves the attribute to a header" do
+    expect(response.status).to eq(200)
+    expect(JSON.parse(response.body)).to eq("bar" => "bar value")
+
+    expect(response.headers["foo_header"]).to eq("foo value")
+  end
+
+  it "makes changes in the manifest" do
+    manifest = command_connector.foobara_manifest
+
+    expect(manifest[:command][:SomeCommand][:result_type]).to eq(
+      type: :attributes,
+      element_type_declarations: {
+        bar: { type: :string }
+      }
+    )
+  end
+end

src/http/response.rb

@@ -19,6 +19,11 @@ def cookies
         def add_cookie(cookie_name, cookie_value, cookie_opts)
           cookies << Cookie.new(cookie_name, cookie_value, **cookie_opts)
         end
+
+        def add_header(header_name, header_value)
+          self.headers ||= {}
+          headers[header_name] = header_value
+        end
       end
     end
   end

src/http/response_mutators/move_attribute_to_header.rb

@@ -0,0 +1,42 @@
+module Foobara
+  module CommandConnectors
+    class Http < CommandConnector
+      class MoveAttributeToHeader < ResponseMutator
+        class << self
+          attr_accessor :attribute_name, :header_name
+
+          def for(attribute_name, header_name = attribute_name)
+            subclass = Class.new(self)
+
+            subclass.attribute_name = attribute_name
+            subclass.header_name = header_name
+
+            subclass
+          end
+        end
+
+        attr_writer :attribute_name, :header_name
+
+        def result_type_from(result_type)
+          new_declaration = TypeDeclarations::Attributes.reject(result_type.declaration_data, attribute_name)
+          Domain.current.foobara_type_from_declaration(new_declaration)
+        end
+
+        def mutate(response)
+          if response.command.success?
+            header_value = response.body.delete(attribute_name)
+            response.add_header(header_name, header_value)
+          end
+        end
+
+        def attribute_name
+          @attribute_name ||= self.class.attribute_name
+        end
+
+        def header_name
+          @header_name ||= self.class.header_name
+        end
+      end
+    end
+  end
+end