Add hash field to actions in CWS agent rules

[api-clients-generation-pipeline]

See DataDog/datadog-api-spec#3957
Test branch datadog-api-spec/test/quentin.guillard/add-hash-field-to-cws-agent-rule

[datadog-datadog-prod-us1]

Datadog Report

Branch report: datadog-api-spec/generated/3957
Commit report: 818de82
Test service: datadog-api-client-ruby

❌ 10 Failed (0 Known Flaky), 86 Passed, 1588 Skipped, 40.63s Total duration (35.31s time saved)

❌ Failed Tests (10)

This report shows up to 5 failed tests.

• Create a Workload Protection agent rule with set action returns "OK" response - CSM Threats at features/v2/csm_threats.feature

• Create a Workload Protection agent rule with set action returns "OK" response - CSM Threats at features/v2/csm_threats.feature

• Delete a Workload Protection agent rule returns "OK" response - CSM Threats at features/v2/csm_threats.feature

• Delete a Workload Protection agent rule returns "OK" response - CSM Threats at features/v2/csm_threats.feature

• Get all Workload Protection agent rules returns "OK" response - CSM Threats at features/v2/csm_threats.feature - Details

  Expand for error

   uninitialized constant DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleActionHash
   Did you mean?  DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleKill
                  DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleAttributes
                  DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleData
                  DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleType
                  DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleCreateData
                  DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleActionMetadata
                  DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleActionSet
                  DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleUpdateData
                  DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleResponse
  

[datadog-datadog-prod-us1]

🔵 Code Quality Violation

Avoid nested methods (...read more)

The Ruby static analysis rule "Prevent nested method" discourages defining a method within another method. This practice is generally discouraged in Ruby because the inner method is not actually defined within the scope of the outer method as one might expect, but rather in the same scope as the outer method. This can lead to unexpected behavior and make code more difficult to understand and maintain.

This rule is important because it promotes good coding practices and helps to prevent potential bugs. Nested methods can lead to confusing code and unintended side effects, making your code more difficult to debug and maintain. Furthermore, nested methods are not a common practice in Ruby and can be surprising to other developers who read your code.

To avoid violating this rule, define all methods at the same level of scope. Instead of defining a method within another method, define each method separately and call them as needed. If you find that you are frequently defining methods within other methods, it may be a sign that your code could be structured more effectively, for example by using classes or modules.

    

[datadog-datadog-prod-us1]

⚪ Code Quality Violation

Consider using string interpolation or formatting instead of concatenation. (...read more)

The rule "Avoid string concatenation" is an important coding practice in Ruby for ensuring efficient and clean code. String concatenation in Ruby using the '+' operator creates a new string object, which can lead to excessive memory usage and slower performance when dealing with large strings or performing the operation multiple times.

Instead, Ruby provides alternatives that are more efficient. The string interpolation syntax #{} allows you to insert variables directly into strings without creating new string objects. This is not only more memory efficient, but also provides cleaner and more readable code.

Another alternative is the format method, which allows you to create a formatted string with placeholders for variables. This method is particularly useful when dealing with more complex strings, as it provides a clear and concise way to format your strings.

By following this rule, you can write more efficient and cleaner Ruby code, leading to better performance and readability.