Refactor parsing test variations

Author: rwbutler

FeatureFlags/Classes/Model/Feature+Codable.swift

@@ -21,6 +21,7 @@ extension Feature: Codable {
         case testVariations = "test-variations"
         case labels = "labels"
     }
+    static let defaultTestVariations: [TestVariation] = [.enabled, .disabled]
 
     public init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
@@ -38,76 +39,71 @@ extension Feature: Codable {
         }
         let testBiases = try container.decodeIfPresent([Percentage].self, forKey: .testBiases)
         self.testVariationAssignment = try container.decodeIfPresent(Double.self, forKey: .testVariationAssignment)
-            ?? Double.random(in: 0..<100) // [0.0, 100.0)
+        ?? Double.random(in: 0..<100) // [0.0, 100.0)
         let testVariations = try container.decodeIfPresent([String].self, forKey: .testVariations)
-        let defaultTestVariations = [TestVariation(rawValue: "Enabled"), TestVariation(rawValue: "Disabled")]
         self.unlocked = unlocked
+        let parsedTestVariations: [TestVariation]
         if let testVariations = testVariations {
-            if testVariations.isEmpty {
+            switch testVariations.count {
+            case 0:
                 self.isDevelopment = isDevelopment ?? false
                 self.enabled = isEnabled ?? false
-                self.testVariations = defaultTestVariations
                 self.type = type ?? .featureFlag
                 self.testVariationAssignment = enabled ? 1.0 : 99.0
-            } else if testVariations.count == 1, let firstVariation = testVariations.first {
+                parsedTestVariations = Self.defaultTestVariations
+            case 1:
                 self.enabled = isEnabled ?? false
                 self.isDevelopment = isDevelopment ?? false
-                self.testVariations = [TestVariation(rawValue: firstVariation),
-                                       TestVariation(rawValue: "!\(firstVariation)")]
                 self.type = type ?? .featureFlag
-            } else if testVariations.count == 2 {
+                if let firstVariation = testVariations.first {
+                    parsedTestVariations = [
+                        TestVariation(rawValue: firstVariation),
+                        TestVariation(rawValue: "!\(firstVariation)")
+                    ]
+                } else {
+                    parsedTestVariations = Self.defaultTestVariations
+                }
+            case 2:
                 self.enabled = isEnabled ?? true
                 self.isDevelopment = isDevelopment ?? false
-                let testVariations = testVariations.map({ TestVariation(rawValue: $0) })
-                if Feature.testVariationsContains(variationNames: ["enabled", "disabled"], in: testVariations)
-                    || Feature.testVariationsContains(variationNames: ["on", "off"], in: testVariations) {
-                    self.type = type ?? .featureTest(.featureFlagAB)
-                    self.testVariations = defaultTestVariations
-                } else {
-                    self.type = type ?? .featureTest(.ab)
-                    self.testVariations = testVariations
+                parsedTestVariations = testVariations.map {
+                    TestVariation(rawValue: $0)
                 }
-            } else {
+                self.type = parsedTestVariations.sorted() == Self.defaultTestVariations.sorted()
+                ? .featureTest(.featureFlagAB)
+                : .featureTest(.ab)
+            default:
                 self.enabled = isEnabled ?? true
                 self.isDevelopment = isDevelopment ?? false
-                self.testVariations = testVariations.map({ TestVariation(rawValue: $0) })
+                parsedTestVariations = testVariations.map {
+                    TestVariation(rawValue: $0)
+                }
                 self.type = type ?? .featureTest(.mvt)
             }
         } else {
             self.enabled = isEnabled ?? false
             self.isDevelopment = isDevelopment ?? false
-            self.testVariations = defaultTestVariations
             self.type = type ?? .featureFlag
             self.testVariationAssignment = enabled ? 1.0 : 99.0
+            parsedTestVariations = Self.defaultTestVariations
         }
-        let variations = self.testVariations // Silences compiler error
+        self.testVariations = parsedTestVariations
         if let testBiases = testBiases,
-            testBiases.reduce(Percentage.min, { (runningTotal, testBias) -> Percentage in
-                return runningTotal + testBias
-            }) == Percentage.max,
-            testBiases.count == variations.count {
+           testBiases.reduce(Percentage.min, { (runningTotal, testBias) -> Percentage in
+               return runningTotal + testBias
+           }) == Percentage.max,
+           testBiases.count == parsedTestVariations.count {
             self.testBiases = testBiases
         } else {
-            self.testBiases = variations.map({ _ in
-                return Percentage(rawValue: 100.0 / Double(variations.count))
+            self.testBiases = parsedTestVariations.map({ _ in
+                return Percentage(rawValue: 100.0 / Double(parsedTestVariations.count))
             })
         }
         self.labels = try container.decodeIfPresent([String?].self, forKey: .labels)
-            ?? [String?](repeating: nil, count: variations.count)
+        ?? [String?](repeating: nil, count: parsedTestVariations.count)
         self.testVariationOverride = nil
     }
 
-    private static func testVariationsContains(variationNames: [String], in variations: [Test.Variation]) -> Bool {
-        var variationsFound: Bool = false
-        for variationName in variationNames {
-            variationsFound = variations.contains(where: { testVariation in
-                return testVariation.rawValue.lowercased() == variationName
-            })
-            if !variationsFound { break }
-        }
-        return variationsFound
-    }
-    
     public func encode(to encoder: Encoder) throws {
         var container = encoder.container(keyedBy: CodingKeys.self)
         try container.encode(name, forKey: .name)

FeatureFlags/Classes/Model/Feature.swift

@@ -9,7 +9,7 @@ import Foundation
 
 public struct Feature {
 
-    // MARK: Type defintions
+    // MARK: Type definitions
     public typealias Name = FeatureName
 
     // MARK: State

FeatureFlags/Classes/Model/TestVariation.swift

@@ -22,21 +22,39 @@ public struct TestVariation: RawRepresentable {
     // Note: A logic error has occurred and a Test.Variation could not be assigned.
     public static let unassigned = Test.Variation(rawValue: "Unassigned")
 
+    private static let disabledRawValues = ["disabled", "off"]
+    private static let enabledRawValues = ["enabled", "on"]
     private let name: RawValue
     public typealias RawValue = String
 
     public init(rawValue: RawValue) {
-        self.name = rawValue
+        name = Self.name(from: rawValue)
     }
 
     public var rawValue: RawValue {
-        return self.name
+        return name
+    }
+    
+    static func name(from rawValue: RawValue) -> String {
+        if disabledRawValues.contains(rawValue) {
+            return Self.disabled.rawValue
+        } else if enabledRawValues.contains(rawValue) {
+            return Self.enabled.rawValue
+        } else {
+            return rawValue
+        }
     }
 }
 
 extension TestVariation: Equatable {
     public static func == (lhs: TestVariation, rhs: TestVariation) -> Bool {
-        return lhs.rawValue.lowercased() == rhs.rawValue.lowercased()
+        lhs.rawValue.lowercased() == rhs.rawValue.lowercased()
+    }
+}
+
+extension TestVariation: Comparable {
+    public static func < (lhs: TestVariation, rhs: TestVariation) -> Bool {
+        lhs.rawValue.lowercased() < rhs.rawValue.lowercased()
     }
 }