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)
  }
}