Better expectation diffs in tests

Author: AliSoftware

spec/ios_send_app_size_metrics_spec.rb

@@ -43,46 +43,65 @@
 
 # A test double to mock the Gzip compression and keep the 'fake-compressed' result readable in test failures
 class GzipWriterDouble < StringIO
+  GZIP_PREFIX = '$GZIP$:'.freeze
   def close
     super
-    self # `GzipWriter#close` returns `self` after closing (allowing method chaining), unlike default `StringIO#close`
+    # `GzipWriter#close` returns `self` after closing (allowing use to use method chaining), unlike `StringIO#close`
+    self
   end
 
   def string
-    "GZIP<#{super}>"
+    "#{GZIP_PREFIX}#{super}"
   end
 end
 
 describe Fastlane::Actions::IosSendAppSizeMetricsAction do
   let(:test_data_dir) { File.join(File.dirname(__FILE__), 'test-data', 'app_size_metrics') }
+  let(:mocked_endpoint) { 'https://localhost/api/metrics' }
+  let(:mocked_token) { 'token/1' }
+
+  # Utility method to turn a minified JSON into a pretty-formatted JSON (without the GZIP fake prefix if any)
+  # To make any test failure and diff easier to debug
+  def pretty_json(json_string)
+    JSON.pretty_generate(JSON.parse(json_string.delete_prefix(GzipWriterDouble::GZIP_PREFIX)))
+  end
 
   def test_app_size_action(fake_ipa_size:, expected_json:, **other_action_args)
-    mocked_endpoint = 'https://localhost/api/metrics'
     in_tmp_dir do |tmp_dir|
+      # Arrange: Generate a fake `.ipa` file with the expected size
       ipa_path = File.join(tmp_dir, 'fake.ipa')
       File.write(ipa_path, SecureRandom.random_bytes(fake_ipa_size))
+
+      # Arrange: Mock GzipWriter with a mock for easier debugging in case of test failures
       allow(Zlib::GzipWriter).to receive(:new).and_return(GzipWriterDouble.new)
 
+      # Arrange: Stub any request to the mocked_endpoint, and memorize the received body
       expected_headers = {
-        Authorization: 'Bearer token/1',
+        Authorization: "Bearer #{mocked_token}",
         'Content-Type': 'application/json',
         'Content-Encoding': 'gzip'
       }
+      last_received_body = nil
+      stub = stub_request(:post, mocked_endpoint).with(headers: expected_headers) do |req|
+        last_received_body = req.body
+      end.to_return(status: 200)
 
-      stub = stub_request(:post, mocked_endpoint).with(
-        headers: expected_headers,
-        body: "GZIP<#{expected_json}>"
-      ).to_return(status: 200)
-
+      # Act
       code = run_described_fastlane_action(
         api_base_url: mocked_endpoint,
-        api_token: 'token/1',
+        api_token: mocked_token,
         ipa_path: ipa_path,
         **other_action_args
       )
 
+      # Asserts
       expect(stub).to have_been_made.once
       expect(code).to eq(200)
+      expect(last_received_body).to start_with(GzipWriterDouble::GZIP_PREFIX), 'Payload is expected to be GZipped, but was not'
+      # Compare the payloads as pretty-formatted JSON, to make the diff in test failures more readable if one happen
+      expect(pretty_json(last_received_body)).to eq(pretty_json(expected_json)), 'Decompressed JSON payload was not as expected'
+      # Compare the payloads as raw strings as a final check
+      expect(last_received_body).to eq(GzipWriterDouble.new(expected_json).string)
     end
   end