fix stack_trace spec for new architecture

Author: vpellan

spec/datadog/appsec/stack_trace_spec.rb

@@ -1,90 +1,78 @@
 require 'datadog/appsec/stack_trace'
 require 'support/thread_backtrace_helpers'
 
-RSpec.describe Datadog::AppSec::StackTrace do
-  subject(:dd_stack_trace) { described_class.new(id, stack_trace, message: message) }
+RSpec.describe Datadog::AppSec::StackTrace::Collection do
+  subject(:collection) { described_class.new(frames) }
 
   before do
     Datadog.configure do |c|
-      c.appsec.stack_trace.enabled = stack_trace_enabled if stack_trace_enabled
       c.appsec.stack_trace.max_depth = max_depth if max_depth
       c.appsec.stack_trace.max_depth_top_percent = max_depth_top_percent if max_depth_top_percent
-      c.appsec.stack_trace.max_collect = max_collect if max_collect
     end
   end
 
-  let(:id) { 'b7e2370c-5d7e-4d32-990b-8812abf36588' }
   # "/app/spec/support/thread_backtrace_helpers.rb:12:in `block in locations_inside_nested_blocks'",
   # "/app/spec/support/thread_backtrace_helpers.rb:14:in `block (2 levels) in locations_inside_nested_blocks'",
   # "/app/spec/support/thread_backtrace_helpers.rb:16:in `block (3 levels) in locations_inside_nested_blocks'",
   # "/app/spec/support/thread_backtrace_helpers.rb:16:in `block (4 levels) in locations_inside_nested_blocks'",
   # "/app/spec/support/thread_backtrace_helpers.rb:16:in `block (5 levels) in locations_inside_nested_blocks'",
-  let(:stack_trace) { ThreadBacktraceHelper.locations_inside_nested_blocks }
-  let(:message) { 'This is a test message' }
+  let(:frames) { ThreadBacktraceHelper.locations_inside_nested_blocks }
 
   # This should use default values
-  let(:stack_trace_enabled) { nil }
   let(:max_depth) { nil }
   let(:max_depth_top_percent) { nil }
-  let(:max_collect) { nil }
 
   describe '::new' do
     context 'with default values' do
       it 'creates a stack trace with default values' do
-        expect(dd_stack_trace.id).to eq(id)
-        expect(dd_stack_trace.id.encoding).to eq(Encoding::UTF_8)
-        expect(dd_stack_trace.message).to eq(message)
-        expect(dd_stack_trace.message.encoding).to eq(Encoding::UTF_8)
-        expect(dd_stack_trace.frames.size).to eq(5)
+        expect(collection.count).to eq(5)
       end
     end
 
     context 'without values' do
-      let(:id) { nil }
-      let(:stack_trace) { nil }
-      let(:message) { nil }
+      let(:frames) { nil }
 
       it 'does not cause an error' do
-        expect { dd_stack_trace }.to_not raise_error
+        expect { collection }.to_not raise_error
       end
     end
 
     context 'with max_depth set to 4' do
       let(:max_depth) { 4 }
 
       it 'creates a stack trace with 4 frames, 3 top' do
-        expect(dd_stack_trace.frames.size).to eq(4)
-        expect(dd_stack_trace.frames[2].text).to eq(stack_trace[2].to_s)
-        expect(dd_stack_trace.frames[3].text).to eq(stack_trace[4].to_s)
+        expect(collection.count).to eq(4)
+        expect(collection[2].text).to eq(frames[2].to_s)
+        expect(collection[3].text).to eq(frames[4].to_s)
       end
 
       context 'with max_depth_top_percent set to 25' do
         let(:max_depth_top_percent) { 25 }
 
         it 'creates a stack trace with 4 frames, 1 top' do
-          expect(dd_stack_trace.frames.size).to eq(4)
-          expect(dd_stack_trace.frames[0].text).to eq(stack_trace[0].to_s)
-          expect(dd_stack_trace.frames[1].text).to eq(stack_trace[2].to_s)
+          expect(collection.count).to eq(4)
+          expect(collection[0].text).to eq(frames[0].to_s)
+          expect(collection[1].text).to eq(frames[2].to_s)
         end
       end
 
       context 'with max_depth_top_percent set to 100' do
         let(:max_depth_top_percent) { 100 }
 
         it 'creates a stack trace with 4 top frames' do
-          expect(dd_stack_trace.frames.size).to eq(4)
-          expect(dd_stack_trace.frames[0].text).to eq(stack_trace[0].to_s)
-          expect(dd_stack_trace.frames[3].text).to eq(stack_trace[3].to_s)
+          expect(collection.count).to eq(4)
+          expect(collection[0].text).to eq(frames[0].to_s)
+          expect(collection[3].text).to eq(frames[3].to_s)
         end
       end
 
       context 'with max_depth_top_percent set to 0' do
         let(:max_depth_top_percent) { 0 }
 
         it 'creates a stack trace with 4 bottom frames' do
-          expect(dd_stack_trace.frames.size).to eq(4)
-          expect(dd_stack_trace.frames[0].text).to eq(stack_trace[1].to_s)
-          expect(dd_stack_trace.frames[3].text).to eq(stack_trace[4].to_s)
+          expect(collection.count).to eq(4)
+          expect(collection[0].text).to eq(frames[1].to_s)
+          expect(collection[3].text).to eq(frames[4].to_s)
         end
       end
     end
@@ -96,9 +84,9 @@
         let(:max_depth_top_percent) { 200 / 3.0 }
 
         it 'creates a stack trace with 3 frames, 2 top' do
-          expect(dd_stack_trace.frames.size).to eq(3)
-          expect(dd_stack_trace.frames[1].text).to eq(stack_trace[1].to_s)
-          expect(dd_stack_trace.frames[2].text).to eq(stack_trace[4].to_s)
+          expect(collection.count).to eq(3)
+          expect(collection[1].text).to eq(frames[1].to_s)
+          expect(collection[2].text).to eq(frames[4].to_s)
         end
       end
     end
@@ -107,50 +95,31 @@
       let(:max_depth) { 0 }
 
       it 'does not apply any limit' do
-        expect(dd_stack_trace.frames.size).to eq(5)
+        expect(collection.count).to eq(5)
       end
     end
   end
 
-  describe '#to_h' do
-    # To simplify the test, we set max_depth to 1
-    let(:max_depth) { 1 }
-
-    it 'returns a hash with correct values' do
-      expect(dd_stack_trace.to_h).to eq(
-        {
-          language: 'ruby',
-          id: id,
-          message: message,
-          frames: [
-            {
-              id: 0,
-              text: stack_trace.first.to_s,
-              file: stack_trace.first.absolute_path,
-              line: stack_trace.first.lineno,
-              function: stack_trace.first.label
-            }
-          ]
-        }
-      )
+  describe '#each' do
+    it 'iterates over the frames' do
+      expect(collection.each.to_a).to eq(collection.instance_variable_get('@frames'))
     end
   end
 
   describe '#to_msgpack' do
     it 'returns a MessagePack object with correct values' do
-      stack_trace_msgpack = dd_stack_trace.to_msgpack
+      stack_trace_msgpack = collection.to_msgpack
 
       expect(stack_trace_msgpack).to be_a(MessagePack::Packer)
       # As message pack converts keys to string,
       # we must also convert the keys of the hash to string in this test
-      result = dd_stack_trace.to_h.transform_keys(&:to_s)
-      result['frames'] = result['frames'].map { |f| f.transform_keys(&:to_s) }
+      result = collection.map { |f| f.to_h.transform_keys(&:to_s) }
 
       expect(MessagePack.unpack(stack_trace_msgpack.to_s)).to eq(result)
     end
   end
 
-  # add_stack_trace must be tested in integration tests, as it uses the active context
+  # Integration tests done in rails integration test spec
 end
 
 RSpec.describe Datadog::AppSec::StackTrace::Frame do
@@ -200,3 +169,46 @@
     end
   end
 end
+
+RSpec.describe Datadog::AppSec::StackTrace::Representation do
+  subject(:dd_stack_trace) { described_class.new(id, stack_trace, message: message) }
+
+  let(:id) { 'stack_id' }
+  let(:stack_trace) { Datadog::AppSec::StackTrace::Collection.new(ThreadBacktraceHelper.locations_inside_nested_blocks) }
+  let(:message) { 'Test message' }
+
+  describe '::new' do
+    it 'creates a stack trace representation with correct values' do
+      expect(dd_stack_trace.id).to eq(id)
+      expect(dd_stack_trace.stack_trace).to eq(stack_trace)
+      expect(dd_stack_trace.message).to eq(message)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with correct values' do
+      expect(dd_stack_trace.to_h).to eq(
+        {
+          language: 'ruby',
+          id: id,
+          message: message,
+          frames: stack_trace.map(&:to_h)
+        }
+      )
+    end
+  end
+
+  describe '#to_msgpack' do
+    it 'returns a MessagePack object with correct values' do
+      stack_trace_msgpack = dd_stack_trace.to_msgpack
+
+      expect(stack_trace_msgpack).to be_a(MessagePack::Packer)
+      # As message pack converts keys to string,
+      # we must also convert the keys of the hash to string in this test
+      result = dd_stack_trace.to_h.transform_keys(&:to_s)
+      result['frames'] = result['frames'].map { |f| f.transform_keys(&:to_s) }
+
+      expect(MessagePack.unpack(stack_trace_msgpack.to_s)).to eq(result)
+    end
+  end
+end