Collect UMA data for Origin Trials

content/common/origin_trials/trial_token_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/common/origin_trials/trial_token.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
@@ skipping 135 matching lines @@
         valid_timestamp_(base::Time::FromDoubleT(kValidTimestamp)),
         invalid_timestamp_(base::Time::FromDoubleT(kInvalidTimestamp)),
         correct_public_key_(
             base::StringPiece(reinterpret_cast<const char*>(kTestPublicKey),
                               arraysize(kTestPublicKey))),
         incorrect_public_key_(
             base::StringPiece(reinterpret_cast<const char*>(kTestPublicKey2),
                               arraysize(kTestPublicKey2))) {}
 
  protected:
-  std::unique_ptr<std::string> Extract(const std::string& token_text,
-                                       base::StringPiece public_key) {
-    return TrialToken::Extract(token_text, public_key);
+  TrialTokenStatus Extract(const std::string& token_text,
+                           base::StringPiece public_key,
+                           std::string* token_payload) {
+    return TrialToken::Extract(token_text, public_key, token_payload);
   }
+
+  TrialTokenStatus ExtractIgnorePayload(const std::string& token_text,
+                                        base::StringPiece public_key) {
+    std::string token_payload;
+    return Extract(token_text, public_key, &token_payload);
+  }
+
   std::unique_ptr<TrialToken> Parse(const std::string& token_payload) {
     return TrialToken::Parse(token_payload);
   }
 
   bool ValidateOrigin(TrialToken* token, const url::Origin origin) {
     return token->ValidateOrigin(origin);
   }
 
   bool ValidateFeatureName(TrialToken* token, const char* feature_name) {
     return token->ValidateFeatureName(feature_name);
@@ skipping 19 matching lines @@
   base::StringPiece incorrect_public_key_;
 };
 
 // Test the extraction of the signed payload from token strings. This includes
 // checking the included version identifier, payload length, and cryptographic
 // signature.
 
 // Test verification of signature and extraction of token JSON from signed
 // token.
 TEST_F(TrialTokenTest, ValidateValidSignature) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kSampleToken, correct_public_key());
-  ASSERT_TRUE(token_payload);
-  EXPECT_STREQ(kSampleTokenJSON, token_payload.get()->c_str());
+  std::string token_payload;
+  TrialTokenStatus status =
+      Extract(kSampleToken, correct_public_key(), &token_payload);
+  ASSERT_EQ(TRIAL_TOKEN_STATUS_SUCCESS, status);
+  EXPECT_STREQ(kSampleTokenJSON, token_payload.c_str());
 }
 
 TEST_F(TrialTokenTest, ValidateInvalidSignature) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kInvalidSignatureToken, correct_public_key());
-  ASSERT_FALSE(token_payload);
+  TrialTokenStatus status =
+      ExtractIgnorePayload(kInvalidSignatureToken, correct_public_key());
+  // TODO(chasej): Recreate the invalid token, and change to
+  // TRIAL_TOKEN_STATUS_INVALID_SIGNATURE
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_MALFORMED, status);
 }
 
 TEST_F(TrialTokenTest, ValidateSignatureWithIncorrectKey) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kSampleToken, incorrect_public_key());
-  ASSERT_FALSE(token_payload);
+  TrialTokenStatus status =
+      ExtractIgnorePayload(kSampleToken, incorrect_public_key());
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_INVALID_SIGNATURE, status);
 }
 
 TEST_F(TrialTokenTest, ValidateEmptyToken) {
-  std::unique_ptr<std::string> token_payload =
-      Extract("", correct_public_key());
-  ASSERT_FALSE(token_payload);
+  TrialTokenStatus status = ExtractIgnorePayload("", correct_public_key());
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_MALFORMED, status);
 }
 
 TEST_F(TrialTokenTest, ValidateShortToken) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kTruncatedToken, correct_public_key());
-  ASSERT_FALSE(token_payload);
+  TrialTokenStatus status =
+      ExtractIgnorePayload(kTruncatedToken, correct_public_key());
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_MALFORMED, status);
 }
 
 TEST_F(TrialTokenTest, ValidateUnsupportedVersion) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kIncorrectVersionToken, correct_public_key());
-  ASSERT_FALSE(token_payload);
+  TrialTokenStatus status =
+      ExtractIgnorePayload(kIncorrectVersionToken, correct_public_key());
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_MALFORMED, status);
 }
 
 TEST_F(TrialTokenTest, ValidateSignatureWithIncorrectLength) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kIncorrectLengthToken, correct_public_key());
-  ASSERT_FALSE(token_payload);
+  TrialTokenStatus status =
+      ExtractIgnorePayload(kIncorrectLengthToken, correct_public_key());
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_MALFORMED, status);
 }
 
 // Test parsing of fields from JSON token.
 
 TEST_F(TrialTokenTest, ParseEmptyString) {
   std::unique_ptr<TrialToken> empty_token = Parse("");
   EXPECT_FALSE(empty_token);
 }
 
 TEST_P(TrialTokenTest, ParseInvalidString) {
@@ skipping 23 matching lines @@
       token.get(), base::ToUpperASCII(kExpectedFeatureName).c_str()));
   EXPECT_FALSE(ValidateFeatureName(
       token.get(), base::ToLowerASCII(kExpectedFeatureName).c_str()));
   EXPECT_TRUE(ValidateDate(token.get(), valid_timestamp_));
   EXPECT_FALSE(ValidateDate(token.get(), invalid_timestamp_));
 }
 
 TEST_F(TrialTokenTest, TokenIsValidForFeature) {
   std::unique_ptr<TrialToken> token = Parse(kSampleTokenJSON);
   ASSERT_TRUE(token);
-  EXPECT_TRUE(token->IsValidForFeature(expected_origin_, kExpectedFeatureName,
-                                       valid_timestamp_));
-  EXPECT_FALSE(token->IsValidForFeature(
-      expected_origin_, base::ToUpperASCII(kExpectedFeatureName),
-      valid_timestamp_));
-  EXPECT_FALSE(token->IsValidForFeature(
-      expected_origin_, base::ToLowerASCII(kExpectedFeatureName),
-      valid_timestamp_));
-  EXPECT_FALSE(token->IsValidForFeature(invalid_origin_, kExpectedFeatureName,
-                                        valid_timestamp_));
-  EXPECT_FALSE(token->IsValidForFeature(insecure_origin_, kExpectedFeatureName,
-                                        valid_timestamp_));
-  EXPECT_FALSE(token->IsValidForFeature(expected_origin_, kInvalidFeatureName,
-                                        valid_timestamp_));
-  EXPECT_FALSE(token->IsValidForFeature(expected_origin_, kExpectedFeatureName,
-                                        invalid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_SUCCESS,
+            token->IsValidForFeature(expected_origin_, kExpectedFeatureName,
+                                     valid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_WRONG_FEATURE,
+            token->IsValidForFeature(expected_origin_,
+                                     base::ToUpperASCII(kExpectedFeatureName),
+                                     valid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_WRONG_FEATURE,
+            token->IsValidForFeature(expected_origin_,
+                                     base::ToLowerASCII(kExpectedFeatureName),
+                                     valid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_WRONG_ORIGIN,
+            token->IsValidForFeature(invalid_origin_, kExpectedFeatureName,
+                                     valid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_WRONG_ORIGIN,
+            token->IsValidForFeature(insecure_origin_, kExpectedFeatureName,
+                                     valid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_WRONG_FEATURE,
+            token->IsValidForFeature(expected_origin_, kInvalidFeatureName,
+                                     valid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_EXPIRED,
+            token->IsValidForFeature(expected_origin_, kExpectedFeatureName,
+                                     invalid_timestamp_));
+}
+
+// Test overall extraction, to ensure output status matches returned token
+TEST_F(TrialTokenTest, ExtractValidToken) {
+  TrialTokenStatus status;
+  std::unique_ptr<TrialToken> token =
+      TrialToken::From(kSampleToken, correct_public_key(), &status);
+  EXPECT_TRUE(token);
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_SUCCESS, status);
+}
+
+TEST_F(TrialTokenTest, ExtractInvalidSignature) {
+  TrialTokenStatus status;
+  std::unique_ptr<TrialToken> token =
+      TrialToken::From(kSampleToken, incorrect_public_key(), &status);
+  EXPECT_FALSE(token);
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_INVALID_SIGNATURE, status);
+}
+
+TEST_F(TrialTokenTest, ExtractMalformedToken) {
+  TrialTokenStatus status;
+  std::unique_ptr<TrialToken> token =
+      TrialToken::From(kIncorrectLengthToken, correct_public_key(), &status);
+  EXPECT_FALSE(token);
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_MALFORMED, status);
 }
 
 }  // namespace content