From 2aeea0642428e52ba76c3cd88d83101c828d2ae9 Mon Sep 17 00:00:00 2001
From: Gaston Thea <gaston.thea@harness.io>
Date: Mon, 12 May 2025 16:52:59 -0300
Subject: [PATCH] RBS in encryption migration

---
 Split/Common/Utils/DbCipher.swift      | 12 ++++++++++++
 SplitTests/DbCipherTest.swift          | 11 ++++++++++-
 SplitTests/Helpers/TestingHelper.swift |  7 +++++--
 3 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/Split/Common/Utils/DbCipher.swift b/Split/Common/Utils/DbCipher.swift
index a845d5c8..afdd92be 100644
--- a/Split/Common/Utils/DbCipher.swift
+++ b/Split/Common/Utils/DbCipher.swift
@@ -42,6 +42,7 @@ struct DbCipher {
         }
         dbHelper.performAndWait {
             updateSplits()
+            updateRuleBasedSegments()
             updateSegments(type: .mySegment)
             updateSegments(type: .myLargeSegment)
             updateImpressions()
@@ -64,6 +65,17 @@ struct DbCipher {
         }
     }
 
+    private func updateRuleBasedSegments() {
+        let items = dbHelper.fetch(entity: .ruleBasedSegment).compactMap { return $0 as? RuleBasedSegmentEntity }
+        for item in items {
+            let name = fromCipher?.decrypt(item.name) ?? item.name
+            item.name = toCipher?.encrypt(name) ?? name
+
+            let body = fromCipher?.decrypt(item.body) ?? item.body
+            item.body = toCipher?.encrypt(body) ?? body
+        }
+    }
+
     private func updateSegments(type entity: CoreDataEntity) {
         let items = dbHelper.fetch(entity: entity).compactMap { return $0 as? MySegmentEntity }
         for item in items {
diff --git a/SplitTests/DbCipherTest.swift b/SplitTests/DbCipherTest.swift
index e291e258..ebb4660b 100644
--- a/SplitTests/DbCipherTest.swift
+++ b/SplitTests/DbCipherTest.swift
@@ -59,6 +59,9 @@ class DbCipherTest: XCTestCase {
         // Attributes
         XCTAssertNotEqual(userKey, resultBefore.attributes.userKey)
         XCTAssertFalse(resultBefore.attributes.attributes.contains("att1"))
+        // RBS
+        XCTAssertNotEqual("test_rbs", resultBefore.ruleBasedSegments.name)
+        XCTAssertFalse(resultBefore.ruleBasedSegments.body.contains("test_rbs"))
 
         // Decrypted data
         // Splits
@@ -80,6 +83,9 @@ class DbCipherTest: XCTestCase {
         // Attributes
         XCTAssertEqual(userKey, resultAfter.attributes.userKey)
         XCTAssertTrue(resultAfter.attributes.attributes.contains("att1"))
+        // RBS
+        XCTAssertEqual("test_rbs", resultAfter.ruleBasedSegments.name)
+        XCTAssertTrue(resultAfter.ruleBasedSegments.body.contains("test_"))
     }
 
     struct DataResult {
@@ -91,6 +97,7 @@ class DbCipherTest: XCTestCase {
         let impressionsCount: String
         let uniqueKeys: (userKey: String, features: String)
         let attributes: (userKey: String, attributes: String)
+        let ruleBasedSegments: (name: String, body: String)
     }
 
     private func loadData(dbHelper: CoreDataHelper) -> DataResult {
@@ -109,7 +116,8 @@ class DbCipherTest: XCTestCase {
                                 uniqueKeys: dbHelper.fetch(entity: .uniqueKey).compactMap { $0 as? UniqueKeyEntity }.map { (userKey: $0.userKey,
                                                                                                                             features: $0.featureList) }[0],
                                 attributes: dbHelper.fetch(entity: .attribute).compactMap { $0 as? AttributeEntity }.map { (userKey: $0.userKey!,
-                                                                                                                            attributes: $0.attributes!) }[0]
+                                                                                                                            attributes: $0.attributes!) }[0],
+                                ruleBasedSegments: dbHelper.fetch(entity: .ruleBasedSegment).compactMap { $0 as? RuleBasedSegmentEntity }.map { (name: $0.name, body: $0.body )}[0]
             )
         }
         return result!
@@ -129,6 +137,7 @@ class DbCipherTest: XCTestCase {
         db.impressionsCountDao.insert(ImpressionsCountPerFeature(storageId: "id1", feature: "pepe", timeframe: 111111, count: 1) )
         db.uniqueKeyDao.insert(UniqueKey(userKey: IntegrationHelper.dummyUserKey, features: ["split1"]))
         db.attributesDao.update(userKey: userKey, attributes: ["att1": 1])
+        db.ruleBasedSegmentDao.insertOrUpdate(segment: TestingHelper.createRuleBasedSegment())
     }
 
     private func createDbHelper() -> CoreDataHelper {
diff --git a/SplitTests/Helpers/TestingHelper.swift b/SplitTests/Helpers/TestingHelper.swift
index 2719f8ce..e33a45b6 100644
--- a/SplitTests/Helpers/TestingHelper.swift
+++ b/SplitTests/Helpers/TestingHelper.swift
@@ -272,8 +272,11 @@ struct TestingHelper {
         let msChange = SegmentChange(segments: ms, changeNumber: msCn)
         let mlsChange = SegmentChange(segments: mls, changeNumber: mlsCn)
         return try! Json.encodeToJson(newAllSegmentsChange(msChange: msChange, mlsChange: mlsChange))
-
-
     }
 
+    static func createRuleBasedSegment(name: String = "test_rbs", trafficTypeName: String = "user", changeNumber: Int64 = 1000, status: Status = .active, conditions: [Condition]? = nil, excluded: Excluded? = nil) -> RuleBasedSegment {
+        let segment = RuleBasedSegment(name: name, trafficTypeName: trafficTypeName, changeNumber: changeNumber, status: status, conditions: conditions, excluded: excluded)
+        segment.isParsed = true
+        return segment
+    }
 }