diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 52c13bf6e..4f566b6fb 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -50893,6 +50893,8 @@ components: maximum: 5 minimum: 1 type: integer + suppressions: + $ref: '#/components/schemas/SensitiveDataScannerSuppressions' tags: description: List of tags. items: @@ -51114,6 +51116,32 @@ components: type: $ref: '#/components/schemas/SensitiveDataScannerStandardPatternType' type: object + SensitiveDataScannerSuppressions: + description: 'Object describing the suppressions for a rule. There are three + types of suppressions, `starts_with`, `ends_with`, and `exact_match`. + + Suppressed matches are not obfuscated, counted in metrics, or displayed in + the Findings page.' + properties: + ends_with: + description: List of strings to use for suppression of matches ending with + these strings. + items: + type: string + type: array + exact_match: + description: List of strings to use for suppression of matches exactly matching + these strings. + items: + type: string + type: array + starts_with: + description: List of strings to use for suppression of matches starting + with these strings. + items: + type: string + type: array + type: object SensitiveDataScannerTextReplacement: description: Object describing how the scanned event will be replaced. properties: diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index 6ead73ce3..4a40605a9 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -6352,6 +6352,8 @@ pub mod model_sensitive_data_scanner_rule_attributes; pub use self::model_sensitive_data_scanner_rule_attributes::SensitiveDataScannerRuleAttributes; pub mod model_sensitive_data_scanner_included_keyword_configuration; pub use self::model_sensitive_data_scanner_included_keyword_configuration::SensitiveDataScannerIncludedKeywordConfiguration; +pub mod model_sensitive_data_scanner_suppressions; +pub use self::model_sensitive_data_scanner_suppressions::SensitiveDataScannerSuppressions; pub mod model_sensitive_data_scanner_text_replacement; pub use self::model_sensitive_data_scanner_text_replacement::SensitiveDataScannerTextReplacement; pub mod model_sensitive_data_scanner_text_replacement_type; diff --git a/src/datadogV2/model/model_sensitive_data_scanner_rule_attributes.rs b/src/datadogV2/model/model_sensitive_data_scanner_rule_attributes.rs index 67758c86b..19c199460 100644 --- a/src/datadogV2/model/model_sensitive_data_scanner_rule_attributes.rs +++ b/src/datadogV2/model/model_sensitive_data_scanner_rule_attributes.rs @@ -40,6 +40,10 @@ pub struct SensitiveDataScannerRuleAttributes { /// Integer from 1 (high) to 5 (low) indicating rule issue severity. #[serde(rename = "priority")] pub priority: Option, + /// Object describing the suppressions for a rule. There are three types of suppressions, `starts_with`, `ends_with`, and `exact_match`. + /// Suppressed matches are not obfuscated, counted in metrics, or displayed in the Findings page. + #[serde(rename = "suppressions")] + pub suppressions: Option, /// List of tags. #[serde(rename = "tags")] pub tags: Option>, @@ -64,6 +68,7 @@ impl SensitiveDataScannerRuleAttributes { namespaces: None, pattern: None, priority: None, + suppressions: None, tags: None, text_replacement: None, additional_properties: std::collections::BTreeMap::new(), @@ -114,6 +119,14 @@ impl SensitiveDataScannerRuleAttributes { self } + pub fn suppressions( + mut self, + value: crate::datadogV2::model::SensitiveDataScannerSuppressions, + ) -> Self { + self.suppressions = Some(value); + self + } + pub fn tags(mut self, value: Vec) -> Self { self.tags = Some(value); self @@ -169,6 +182,9 @@ impl<'de> Deserialize<'de> for SensitiveDataScannerRuleAttributes { let mut namespaces: Option> = None; let mut pattern: Option = None; let mut priority: Option = None; + let mut suppressions: Option< + crate::datadogV2::model::SensitiveDataScannerSuppressions, + > = None; let mut tags: Option> = None; let mut text_replacement: Option< crate::datadogV2::model::SensitiveDataScannerTextReplacement, @@ -232,6 +248,13 @@ impl<'de> Deserialize<'de> for SensitiveDataScannerRuleAttributes { } priority = Some(serde_json::from_value(v).map_err(M::Error::custom)?); } + "suppressions" => { + if v.is_null() { + continue; + } + suppressions = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } "tags" => { if v.is_null() { continue; @@ -262,6 +285,7 @@ impl<'de> Deserialize<'de> for SensitiveDataScannerRuleAttributes { namespaces, pattern, priority, + suppressions, tags, text_replacement, additional_properties, diff --git a/src/datadogV2/model/model_sensitive_data_scanner_suppressions.rs b/src/datadogV2/model/model_sensitive_data_scanner_suppressions.rs new file mode 100644 index 000000000..ebcc9ca4c --- /dev/null +++ b/src/datadogV2/model/model_sensitive_data_scanner_suppressions.rs @@ -0,0 +1,142 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Object describing the suppressions for a rule. There are three types of suppressions, `starts_with`, `ends_with`, and `exact_match`. +/// Suppressed matches are not obfuscated, counted in metrics, or displayed in the Findings page. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct SensitiveDataScannerSuppressions { + /// List of strings to use for suppression of matches ending with these strings. + #[serde(rename = "ends_with")] + pub ends_with: Option>, + /// List of strings to use for suppression of matches exactly matching these strings. + #[serde(rename = "exact_match")] + pub exact_match: Option>, + /// List of strings to use for suppression of matches starting with these strings. + #[serde(rename = "starts_with")] + pub starts_with: Option>, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl SensitiveDataScannerSuppressions { + pub fn new() -> SensitiveDataScannerSuppressions { + SensitiveDataScannerSuppressions { + ends_with: None, + exact_match: None, + starts_with: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn ends_with(mut self, value: Vec) -> Self { + self.ends_with = Some(value); + self + } + + pub fn exact_match(mut self, value: Vec) -> Self { + self.exact_match = Some(value); + self + } + + pub fn starts_with(mut self, value: Vec) -> Self { + self.starts_with = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for SensitiveDataScannerSuppressions { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for SensitiveDataScannerSuppressions { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct SensitiveDataScannerSuppressionsVisitor; + impl<'a> Visitor<'a> for SensitiveDataScannerSuppressionsVisitor { + type Value = SensitiveDataScannerSuppressions; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut ends_with: Option> = None; + let mut exact_match: Option> = None; + let mut starts_with: Option> = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "ends_with" => { + if v.is_null() { + continue; + } + ends_with = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "exact_match" => { + if v.is_null() { + continue; + } + exact_match = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "starts_with" => { + if v.is_null() { + continue; + } + starts_with = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = SensitiveDataScannerSuppressions { + ends_with, + exact_match, + starts_with, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(SensitiveDataScannerSuppressionsVisitor) + } +} diff --git a/tests/scenarios/features/v2/sensitive_data_scanner.feature b/tests/scenarios/features/v2/sensitive_data_scanner.feature index 4516e1610..6faf84050 100644 --- a/tests/scenarios/features/v2/sensitive_data_scanner.feature +++ b/tests/scenarios/features/v2/sensitive_data_scanner.feature @@ -200,7 +200,7 @@ Feature: Sensitive Data Scanner Scenario: Update Scanning Rule returns "Not Found" response Given new "UpdateScanningRule" request And request contains "rule_id" parameter from "REPLACE.ME" - And body with value {"data": {"attributes": {"excluded_namespaces": ["admin.name"], "included_keyword_configuration": {"character_count": 30, "keywords": ["credit card", "cc"]}, "namespaces": ["admin"], "tags": [], "text_replacement": {"type": "none"}}, "relationships": {"group": {"data": {"type": "sensitive_data_scanner_group"}}, "standard_pattern": {"data": {"type": "sensitive_data_scanner_standard_pattern"}}}, "type": "sensitive_data_scanner_rule"}, "meta": {"version": 0}} + And body with value {"data": {"attributes": {"excluded_namespaces": ["admin.name"], "included_keyword_configuration": {"character_count": 30, "keywords": ["credit card", "cc"]}, "namespaces": ["admin"], "suppressions": {"ends_with": [], "exact_match": [], "starts_with": []}, "tags": [], "text_replacement": {"type": "none"}}, "relationships": {"group": {"data": {"type": "sensitive_data_scanner_group"}}, "standard_pattern": {"data": {"type": "sensitive_data_scanner_standard_pattern"}}}, "type": "sensitive_data_scanner_rule"}, "meta": {"version": 0}} When the request is sent Then the response status is 404 Not Found