1 files changed, 276 insertions, 0 deletions
diff --git a/cvss/v2metric_test.go b/cvss/v2metric_test.go
new file mode 100644
index 0000000..f606ed5
--- /dev/null
+++ b/cvss/v2metric_test.go
@@ -0,0 +1,276 @@
+package cvss
+
+import "testing"
+
+func TestGetV2Metric(t *testing.T) {
+  tests := []struct {
+    val string
+    exp v2Metric
+    ok  bool
+  } {
+    { "AV:N", v2AVNetwork, true },
+    { "AV:A", v2AVAdjacentNetwork, true },
+    { "AV:L", v2AVLocal, true },
+
+    { "AC:L", v2ACLow, true },
+    { "AC:M", v2ACMedium, true },
+    { "AC:H", v2ACHigh, true },
+
+    { "Au:M", v2AuMultiple, true },
+    { "Au:S", v2AuSingle, true },
+    { "Au:N", v2AuNone, true },
+
+    { "C:N", v2CNone, true },
+    { "C:P", v2CPartial, true },
+    { "C:C", v2CComplete, true },
+
+    { "I:N", v2INone, true },
+    { "I:P", v2IPartial, true },
+    { "I:C", v2IComplete, true },
+
+    { "A:N", v2ANone, true },
+    { "A:P", v2APartial, true },
+    { "A:C", v2AComplete, true },
+
+    { "E:ND", v2ENotDefined, true },
+    { "E:U", v2EUnproven, true },
+    { "E:POC", v2EProofOfConcept, true },
+    { "E:F", v2EFunctional, true },
+    { "E:H", v2EHigh, true },
+
+    { "RL:OF", v2RLOfficialFix, true },
+    { "RL:TF", v2RLTemporaryFix, true },
+    { "RL:W", v2RLWorkaround, true },
+    { "RL:U", v2RLUnavailable, true },
+    { "RL:ND", v2RLNotDefined, true },
+
+    { "RC:UC", v2RCUnconfirmed, true },
+    { "RC:UR", v2RCUncorroborated, true },
+    { "RC:C", v2RCConfirmed, true },
+    { "RC:ND", v2RCNotDefined, true },
+
+    { "CDP:N", v2CDPNone, true },
+    { "CDP:L", v2CDPLow, true },
+    { "CDP:LM", v2CDPLowMedium, true },
+    { "CDP:MH", v2CDPMediumHigh, true },
+    { "CDP:H", v2CDPHigh, true },
+    { "CDP:ND", v2CDPNotDefined, true },
+
+    { "TD:N", v2TDNone, true },
+    { "TD:L", v2TDLow, true },
+    { "TD:M", v2TDMedium, true },
+    { "TD:H", v2TDHigh, true },
+    { "TD:ND", v2TDNotDefined, true },
+
+    { "CR:L", v2CRLow, true },
+    { "CR:M", v2CRMedium, true },
+    { "CR:H", v2CRHigh, true },
+    { "CR:ND", v2CRNotDefined, true },
+
+    { "IR:L", v2IRLow, true },
+    { "IR:M", v2IRMedium, true },
+    { "IR:H", v2IRHigh, true },
+    { "IR:ND", v2IRNotDefined, true },
+
+    { "AR:L", v2ARLow, true },
+    { "AR:M", v2ARMedium, true },
+    { "AR:H", v2ARHigh, true },
+    { "AR:ND", v2ARNotDefined, true },
+
+    { "asdf", v2InvalidMetric, false },
+  }
+
+  for _, test := range(tests) {
+    t.Run(test.val, func(t *testing.T) {
+      got, err := getV2Metric(test.val)
+      if test.ok && err == nil && got != test.exp {
+        t.Errorf("got: \"%s\", exp: \"%s\"", got, test.exp)
+      } else if test.ok && err != nil {
+        t.Error(err)
+      } else if !test.ok && err == nil {
+        t.Errorf("got: \"%s\", exp: error", got)
+      }
+    })
+  }
+}
+
+func TestGetV2MetricKey(t *testing.T) {
+  tests := []struct {
+    val v2Metric
+    exp v2Key
+  } {
+    { v2AVNetwork, v2AccessVector },
+    { v2AVAdjacentNetwork, v2AccessVector },
+    { v2AVLocal, v2AccessVector },
+
+    { v2ACLow, v2AccessComplexity },
+    { v2ACMedium, v2AccessComplexity },
+    { v2ACHigh, v2AccessComplexity },
+
+    { v2AuMultiple, v2Authentication },
+    { v2AuSingle, v2Authentication },
+    { v2AuNone, v2Authentication },
+
+    { v2CNone, v2ConfidentialityImpact },
+    { v2CPartial, v2ConfidentialityImpact },
+    { v2CComplete, v2ConfidentialityImpact },
+
+    { v2INone, v2IntegrityImpact },
+    { v2IPartial, v2IntegrityImpact },
+    { v2IComplete, v2IntegrityImpact },
+
+    { v2ANone, v2AvailabilityImpact },
+    { v2APartial, v2AvailabilityImpact },
+    { v2AComplete, v2AvailabilityImpact },
+
+    { v2ENotDefined, v2Exploitability },
+    { v2EUnproven, v2Exploitability },
+    { v2EProofOfConcept, v2Exploitability },
+    { v2EFunctional, v2Exploitability },
+    { v2EHigh, v2Exploitability },
+
+    { v2RLOfficialFix, v2RemediationLevel },
+    { v2RLTemporaryFix, v2RemediationLevel },
+    { v2RLWorkaround, v2RemediationLevel },
+    { v2RLUnavailable, v2RemediationLevel },
+    { v2RLNotDefined, v2RemediationLevel },
+
+    { v2RCUnconfirmed, v2ReportConfidence },
+    { v2RCUncorroborated, v2ReportConfidence },
+    { v2RCConfirmed, v2ReportConfidence },
+    { v2RCNotDefined, v2ReportConfidence },
+
+    { v2CDPNone, v2CollateralDamagePotential },
+    { v2CDPLow, v2CollateralDamagePotential },
+    { v2CDPLowMedium, v2CollateralDamagePotential },
+    { v2CDPMediumHigh, v2CollateralDamagePotential },
+    { v2CDPHigh, v2CollateralDamagePotential },
+    { v2CDPNotDefined, v2CollateralDamagePotential },
+
+    { v2TDNone, v2TargetDistribution },
+    { v2TDLow, v2TargetDistribution },
+    { v2TDMedium, v2TargetDistribution },
+    { v2TDHigh, v2TargetDistribution },
+    { v2TDNotDefined, v2TargetDistribution },
+
+    { v2CRLow, v2ConfidentialityRequirement },
+    { v2CRMedium, v2ConfidentialityRequirement },
+    { v2CRHigh, v2ConfidentialityRequirement },
+    { v2CRNotDefined, v2ConfidentialityRequirement },
+
+    { v2IRLow, v2IntegrityRequirement },
+    { v2IRMedium, v2IntegrityRequirement },
+    { v2IRHigh, v2IntegrityRequirement },
+    { v2IRNotDefined, v2IntegrityRequirement },
+
+    { v2ARLow, v2AvailabilityRequirement },
+    { v2ARMedium, v2AvailabilityRequirement },
+    { v2ARHigh, v2AvailabilityRequirement },
+    { v2ARNotDefined, v2AvailabilityRequirement },
+  }
+
+  for _, test := range(tests) {
+    t.Run(test.val.String(), func(t *testing.T) {
+      got := test.val.Key()
+      if got != test.exp {
+        t.Errorf("got: \"%s\", exp: \"%s\"", got, test.exp)
+      }
+    })
+  }
+}
+
+func TestV2MetricString(t *testing.T) {
+  tests := []struct {
+    val v2Metric
+    exp string
+  } {
+    { v2AVNetwork, "AV:N" },
+    { v2AVAdjacentNetwork, "AV:A" },
+    { v2AVLocal, "AV:L" },
+
+    { v2ACLow, "AC:L" },
+    { v2ACMedium, "AC:M" },
+    { v2ACHigh, "AC:H" },
+
+    { v2AuMultiple, "Au:M" },
+    { v2AuSingle, "Au:S" },
+    { v2AuNone, "Au:N" },
+
+    { v2CNone, "C:N" },
+    { v2CPartial, "C:P" },
+    { v2CComplete, "C:C" },
+
+    { v2INone, "I:N" },
+    { v2IPartial, "I:P" },
+    { v2IComplete, "I:C" },
+
+    { v2ANone, "A:N" },
+    { v2APartial, "A:P" },
+    { v2AComplete, "A:C" },
+
+    { v2ENotDefined, "E:ND" },
+    { v2EUnproven, "E:U" },
+    { v2EProofOfConcept, "E:POC" },
+    { v2EFunctional, "E:F" },
+    { v2EHigh, "E:H" },
+
+    { v2RLOfficialFix, "RL:OF" },
+    { v2RLTemporaryFix, "RL:TF" },
+    { v2RLWorkaround, "RL:W" },
+    { v2RLUnavailable, "RL:U" },
+    { v2RLNotDefined, "RL:ND" },
+
+    { v2RCUnconfirmed, "RC:UC" },
+    { v2RCUncorroborated, "RC:UR" },
+    { v2RCConfirmed, "RC:C" },
+    { v2RCNotDefined, "RC:ND" },
+
+    { v2CDPNone, "CDP:N" },
+    { v2CDPLow, "CDP:L" },
+    { v2CDPLowMedium, "CDP:LM" },
+    { v2CDPMediumHigh, "CDP:MH" },
+    { v2CDPHigh, "CDP:H" },
+    { v2CDPNotDefined, "CDP:ND" },
+
+    { v2TDNone, "TD:N" },
+    { v2TDLow, "TD:L" },
+    { v2TDMedium, "TD:M" },
+    { v2TDHigh, "TD:H" },
+    { v2TDNotDefined, "TD:ND" },
+
+    { v2CRLow, "CR:L" },
+    { v2CRMedium, "CR:M" },
+    { v2CRHigh, "CR:H" },
+    { v2CRNotDefined, "CR:ND" },
+
+    { v2IRLow, "IR:L" },
+    { v2IRMedium, "IR:M" },
+    { v2IRHigh, "IR:H" },
+    { v2IRNotDefined, "IR:ND" },
+
+    { v2ARLow, "AR:L" },
+    { v2ARMedium, "AR:M" },
+    { v2ARHigh, "AR:H" },
+    { v2ARNotDefined, "AR:ND" },
+
+    { v2Metric(255), "v2Metric(255)" },
+  }
+
+  for _, test := range(tests) {
+    t.Run(test.val.String(), func(t *testing.T) {
+      got := test.val.String()
+      if got != test.exp {
+        t.Errorf("got: \"%s\", exp: \"%s\"", got, test.exp)
+      }
+    })
+  }
+}
+
+func TestInvalidV2MetricKey(t *testing.T) {
+  got := v2Metric(255).Key()
+  exp := v2InvalidKey
+
+  if got != exp {
+    t.Errorf("got: \"%s\", exp: \"%s\"", got, exp)
+  }
+}