From f377ce5b8bdd0ce938424f94e70faf09a1ba1318 Mon Sep 17 00:00:00 2001 From: Malcolm Sparrow Date: Wed, 18 Mar 2020 16:54:11 +0000 Subject: [PATCH] Unit tests for virtual grants Resolves https://github.com/brave/brave-browser/issues/6949 - Bind Utils - Promotion - Promotion Utils - Security Helper (Ledger) --- components/definitions/rewards.d.ts | 3 + test/BUILD.gn | 2 + .../bat/ledger/public/interfaces/ledger.mojom | 3 + .../bat/ledger/internal/common/bind_util.cc | 58 ++- .../internal/common/bind_util_unittest.cc | 171 +++++++ .../common/security_helper_unittest.cc | 137 ++++++ .../src/bat/ledger/internal/ledger_impl.h | 6 +- .../bat/ledger/internal/ledger_impl_mock.h | 8 - .../ledger/internal/promotion/promotion.cc | 13 +- .../bat/ledger/internal/promotion/promotion.h | 2 + .../internal/promotion/promotion_unittest.cc | 267 ++++++++++- .../promotion/promotion_util_unittest.cc | 444 ++++++++++++++++++ .../internal/test/mock_ledger_client.cc | 9 - .../ledger/internal/test/mock_ledger_client.h | 14 +- .../ledger/internal/uphold/uphold_unittest.cc | 2 +- 15 files changed, 1088 insertions(+), 51 deletions(-) create mode 100644 vendor/bat-native-ledger/src/bat/ledger/internal/common/bind_util_unittest.cc create mode 100644 vendor/bat-native-ledger/src/bat/ledger/internal/common/security_helper_unittest.cc diff --git a/components/definitions/rewards.d.ts b/components/definitions/rewards.d.ts index b81207e9276c..31cb365cd696 100644 --- a/components/definitions/rewards.d.ts +++ b/components/definitions/rewards.d.ts @@ -121,11 +121,13 @@ declare namespace Rewards { export type CaptchaStatus = 'start' | 'wrongPosition' | 'generalError' | 'finished' | null export enum PromotionTypes { + UNKNOWN = -1, UGP = 0, ADS = 1 } export enum PromotionStatus { + UNKNOWN = -1, ACTIVE = 0, ATTESTED = 1, CLAIMED = 2, @@ -226,6 +228,7 @@ declare namespace Rewards { } export enum RewardsType { + UNKNOWN = -1, AUTO_CONTRIBUTE = 2, ONE_TIME_TIP = 8, RECURRING_TIP = 21 diff --git a/test/BUILD.gn b/test/BUILD.gn index cfa9bb866910..85394f2e0e0d 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -309,6 +309,8 @@ test("brave_unit_tests") { if (brave_rewards_enabled) { sources += [ "//brave/vendor/bat-native-ledger/src/bat/ledger/internal/database/database_activity_info_unittest.cc", + "//brave/vendor/bat-native-ledger/src/bat/ledger/internal/common/bind_util_unittest.cc", + "//brave/vendor/bat-native-ledger/src/bat/ledger/internal/common/security_helper_unittest.cc", "//brave/vendor/bat-native-ledger/src/bat/ledger/internal/contribution/contribution_unittest.cc", "//brave/vendor/bat-native-ledger/src/bat/ledger/internal/contribution/contribution_unblinded_unittest.cc", "//brave/vendor/bat-native-ledger/src/bat/ledger/internal/contribution/contribution_util_unittest.cc", diff --git a/vendor/bat-native-ledger/include/bat/ledger/public/interfaces/ledger.mojom b/vendor/bat-native-ledger/include/bat/ledger/public/interfaces/ledger.mojom index b184232d0543..d3c71d7bd32d 100644 --- a/vendor/bat-native-ledger/include/bat/ledger/public/interfaces/ledger.mojom +++ b/vendor/bat-native-ledger/include/bat/ledger/public/interfaces/ledger.mojom @@ -274,6 +274,7 @@ struct TransferFee { }; enum RewardsType { + UNKNOWN = -1, AUTO_CONTRIBUTE = 2, ONE_TIME_TIP = 8, RECURRING_TIP = 16, @@ -348,11 +349,13 @@ enum Environment { }; enum PromotionType { + UNKNOWN = -1, UGP = 0, ADS = 1 }; enum PromotionStatus { + UNKNOWN = -1, ACTIVE = 0, ATTESTED = 1, CLAIMED = 2, diff --git a/vendor/bat-native-ledger/src/bat/ledger/internal/common/bind_util.cc b/vendor/bat-native-ledger/src/bat/ledger/internal/common/bind_util.cc index 8506196aa100..00260e8f78d4 100644 --- a/vendor/bat-native-ledger/src/bat/ledger/internal/common/bind_util.cc +++ b/vendor/bat-native-ledger/src/bat/ledger/internal/common/bind_util.cc @@ -12,6 +12,58 @@ namespace braveledger_bind_util { +ledger::RewardsType ConvertIntToRewardsType(int type) { + ledger::RewardsType rewards_type = static_cast(type); + + switch (rewards_type) { + case ledger::RewardsType::AUTO_CONTRIBUTE: + case ledger::RewardsType::ONE_TIME_TIP: + case ledger::RewardsType::RECURRING_TIP: { + break; + } + default: { + rewards_type = ledger::RewardsType::UNKNOWN; + } + } + return rewards_type; +} + +ledger::PromotionType ConvertIntToPromotionType(int type) { + ledger::PromotionType promotion_type = + static_cast(type); + + switch (promotion_type) { + case ledger::PromotionType::UGP: + case ledger::PromotionType::ADS: { + break; + } + default: { + promotion_type = ledger::PromotionType::UNKNOWN; + } + } + return promotion_type; +} + +ledger::PromotionStatus ConvertIntToPromotionStatus(int type) { + ledger::PromotionStatus promotion_status = + static_cast(type); + + switch (promotion_status) { + case ledger::PromotionStatus::ACTIVE: + case ledger::PromotionStatus::ATTESTED: + case ledger::PromotionStatus::CLAIMED: + case ledger::PromotionStatus::SIGNED_TOKENS: + case ledger::PromotionStatus::FINISHED: + case ledger::PromotionStatus::OVER: { + break; + } + default: { + promotion_status = ledger::PromotionStatus::UNKNOWN; + } + } + return promotion_status; +} + std::string FromContributionQueueToString(ledger::ContributionQueuePtr info) { base::Value publishers(base::Value::Type::LIST); for (auto& item : info->publishers) { @@ -57,7 +109,7 @@ ledger::ContributionQueuePtr FromStringToContributionQueue( auto* type = dictionary->FindKey("type"); if (type && type->is_int()) { - queue->type = static_cast(type->GetInt()); + queue->type = ConvertIntToRewardsType(type->GetInt()); } auto* amount = dictionary->FindKey("amount"); @@ -168,7 +220,7 @@ ledger::PromotionPtr FromStringToPromotion(const std::string& data) { auto type = dictionary->FindIntKey("type"); if (type) { - promotion->type = static_cast(*type); + promotion->type = ConvertIntToPromotionType(*type); } auto suggestions = dictionary->FindIntKey("suggestions"); @@ -178,7 +230,7 @@ ledger::PromotionPtr FromStringToPromotion(const std::string& data) { auto status = dictionary->FindIntKey("status"); if (status) { - promotion->status = static_cast(*status); + promotion->status = ConvertIntToPromotionStatus(*status); } auto legacy_claimed = dictionary->FindBoolKey("legacy_claimed"); diff --git a/vendor/bat-native-ledger/src/bat/ledger/internal/common/bind_util_unittest.cc b/vendor/bat-native-ledger/src/bat/ledger/internal/common/bind_util_unittest.cc new file mode 100644 index 000000000000..a90e2114d9c8 --- /dev/null +++ b/vendor/bat-native-ledger/src/bat/ledger/internal/common/bind_util_unittest.cc @@ -0,0 +1,171 @@ +/* Copyright (c) 2019 The Brave Authors. All rights reserved. + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include +#include +#include + +#include "bat/ledger/internal/common/bind_util.h" +#include "testing/gtest/include/gtest/gtest.h" +// npm run test -- brave_unit_tests --filter=BindUtilTest.* + +namespace braveledger_bind_util { + +class BindUtilTest : public ::testing::Test { + protected: + BindUtilTest() { + } + + void SetUp() override { + } +}; + +TEST_F(BindUtilTest, ExpectedStringFromContributionQueueToString) { + const int8_t expected_publisher_count = 2; + + ledger::ContributionQueuePublisherList contribution_queue_publisher_list; + + for (int8_t publisher = 0; publisher < expected_publisher_count; + publisher++) { + ledger::ContributionQueuePublisherPtr contribution_queue_publisher = + ledger::ContributionQueuePublisher::New(); + + contribution_queue_publisher->publisher_key = + std::to_string(1000 + publisher); + contribution_queue_publisher->amount_percent = + static_cast(publisher * 25); + contribution_queue_publisher_list.push_back( + std::move(contribution_queue_publisher)); + } + + ledger::ContributionQueuePtr contribution_queue = + ledger::ContributionQueue::New(); + contribution_queue->id = 1234; + contribution_queue->type = ledger::RewardsType::RECURRING_TIP; + contribution_queue->amount = 100.0; + contribution_queue->partial = false; + contribution_queue->publishers = std::move(contribution_queue_publisher_list); + + const std::string expected_contribution_queue_as_string = "{\"amount\":\"100.000000\",\"id\":\"1234\",\"partial\":false,\"publishers\":[{\"amount_percent\":\"0.000000\",\"publisher_key\":\"1000\"},{\"amount_percent\":\"25.000000\",\"publisher_key\":\"1001\"}],\"type\":16}"; // NOLINT + + std::string contribution_queue_as_string = + FromContributionQueueToString(std::move(contribution_queue)); + + EXPECT_EQ(expected_contribution_queue_as_string, + contribution_queue_as_string); +} + +// ledger::ContributionQueuePtr FromStringToContributionQueue( +// const std::string& data); +TEST_F(BindUtilTest, ExpectedContributionQueueFromStringToContributionQueue) { + const std::string contribution_queue_as_string = "{\"amount\":\"100.000000\",\"id\":\"1234\",\"partial\":false,\"publishers\":[{\"amount_percent\":\"0.000000\",\"publisher_key\":\"1000\"},{\"amount_percent\":\"25.000000\",\"publisher_key\":\"1001\"}],\"type\":16}"; // NOLINT + + const uint64_t expected_publisher_count = 2; + + ledger::ContributionQueuePtr contribution_queue = + FromStringToContributionQueue(contribution_queue_as_string); + + EXPECT_EQ(contribution_queue->id, (uint64_t)1234); + EXPECT_EQ(contribution_queue->type, ledger::RewardsType::RECURRING_TIP); + EXPECT_EQ(contribution_queue->amount, 100.0); + EXPECT_EQ(contribution_queue->partial, false); + EXPECT_EQ(contribution_queue->publishers.size(), expected_publisher_count); + + int8_t publisher = 0; + for (auto& contribution_queue_publisher : contribution_queue->publishers) { + EXPECT_EQ(contribution_queue_publisher->publisher_key, + std::to_string(1000 + publisher)); + EXPECT_EQ(contribution_queue_publisher->amount_percent, + static_cast(publisher * 25)); + publisher++; + } +} + +TEST_F(BindUtilTest, + ContributionQueueTypeUnknownFromStringToContributionQueueWithInvalidType) { + const std::string contribution_queue_as_string = "{\"amount\":\"100.000000\",\"id\":\"1234\",\"partial\":false,\"publishers\":[{\"amount_percent\":\"0.000000\",\"publisher_key\":\"1000\"},{\"amount_percent\":\"25.000000\",\"publisher_key\":\"1001\"}],\"type\":17}"; // NOLINT + + ledger::ContributionQueuePtr contribution_queue = + FromStringToContributionQueue(contribution_queue_as_string); + + EXPECT_EQ(contribution_queue->type, ledger::RewardsType::UNKNOWN); +} + +// std::string FromPromotionToString(const ledger::PromotionPtr info); +TEST_F(BindUtilTest, ExpectedStringFromPromotionToString) { + ledger::PromotionCredsPtr promotion_creds = ledger::PromotionCreds::New(); + promotion_creds->tokens = "ABC"; + promotion_creds->blinded_creds = "DEF"; + promotion_creds->signed_creds = "GHI"; + promotion_creds->public_key = "JKL"; + promotion_creds->batch_proof = "MNO"; + promotion_creds->claim_id = "PQR"; + + ledger::PromotionPtr promotion = ledger::Promotion::New(); + promotion->id = "1234"; + promotion->version = 1; + promotion->type = ledger::PromotionType::ADS; + promotion->public_keys = "5678"; + promotion->suggestions = static_cast(1); + promotion->approximate_value = 100.0; + promotion->status = ledger::PromotionStatus::OVER; + promotion->expires_at = static_cast(2); + promotion->claimed_at = static_cast(3); + promotion->legacy_claimed = false; + promotion->credentials = std::move(promotion_creds); + + const std::string expected_promotion_as_string = "{\"approximate_value\":\"100.000000\",\"claimed_at\":\"3\",\"credentials\":{\"batch_proof\":\"MNO\",\"blinded_creds\":\"DEF\",\"claim_id\":\"PQR\",\"public_key\":\"JKL\",\"signed_creds\":\"GHI\",\"tokens\":\"ABC\"},\"expires_at\":\"2\",\"id\":\"1234\",\"legacy_claimed\":false,\"public_keys\":\"5678\",\"status\":5,\"suggestions\":1,\"type\":1,\"version\":1}"; // NOLINT + + std::string promotion_as_string = + FromPromotionToString(std::move(promotion)); + + // Nb. if this test fails due to changes to Promotion or PromotionCreds, + // you must also maintain ExpectedPromotionFromStringToPromotion. + EXPECT_EQ(expected_promotion_as_string, + promotion_as_string); +} + +// ledger::PromotionPtr FromStringToPromotion(const std::string& data); +TEST_F(BindUtilTest, ExpectedPromotionFromStringToPromotion) { + const std::string promotion_as_string = "{\"approximate_value\":\"100.000000\",\"claimed_at\":\"3\",\"credentials\":{\"batch_proof\":\"MNO\",\"blinded_creds\":\"DEF\",\"claim_id\":\"PQR\",\"public_key\":\"JKL\",\"signed_creds\":\"GHI\",\"tokens\":\"ABC\"},\"expires_at\":\"2\",\"id\":\"1234\",\"legacy_claimed\":false,\"public_keys\":\"5678\",\"status\":5,\"suggestions\":1,\"type\":1,\"version\":1}"; // NOLINT + + ledger::PromotionPtr promotion = FromStringToPromotion(promotion_as_string); + + EXPECT_EQ(promotion->id, "1234"); + EXPECT_EQ(promotion->version, static_cast(1)); + EXPECT_EQ(promotion->type, ledger::PromotionType::ADS); + EXPECT_EQ(promotion->public_keys, "5678"); + EXPECT_EQ(promotion->suggestions, static_cast(1)); + EXPECT_EQ(promotion->approximate_value, 100.0); + EXPECT_EQ(promotion->status, ledger::PromotionStatus::OVER); + EXPECT_EQ(promotion->expires_at, static_cast(2)); + EXPECT_EQ(promotion->claimed_at, static_cast(3)); + EXPECT_EQ(promotion->legacy_claimed, false); + EXPECT_EQ(promotion->credentials->tokens, "ABC"); + EXPECT_EQ(promotion->credentials->blinded_creds, "DEF"); + EXPECT_EQ(promotion->credentials->signed_creds, "GHI"); + EXPECT_EQ(promotion->credentials->public_key, "JKL"); + EXPECT_EQ(promotion->credentials->batch_proof, "MNO"); + EXPECT_EQ(promotion->credentials->claim_id, "PQR"); +} + +TEST_F(BindUtilTest, PromotionTypeUnknownFromStringToPromotionWithInvalidType) { + const std::string promotion_as_string = "{\"approximate_value\":\"100.000000\",\"credentials\":{\"batch_proof\":\"MNO\",\"blinded_creds\":\"DEF\",\"claim_id\":\"PQR\",\"public_key\":\"JKL\",\"signed_creds\":\"GHI\",\"tokens\":\"ABC\"},\"expires_at\":\"2\",\"id\":\"1234\",\"legacy_claimed\":false,\"public_keys\":\"5678\",\"status\":5,\"suggestions\":1,\"type\":100,\"version\":1}"; // NOLINT + + ledger::PromotionPtr promotion = FromStringToPromotion(promotion_as_string); + + EXPECT_EQ(promotion->type, ledger::PromotionType::UNKNOWN); +} + +TEST_F(BindUtilTest, + PromotionStatusUnknownFromStringToPromotionWithInvalidStatus) { + const std::string promotion_as_string = "{\"approximate_value\":\"100.000000\",\"credentials\":{\"batch_proof\":\"MNO\",\"blinded_creds\":\"DEF\",\"claim_id\":\"PQR\",\"public_key\":\"JKL\",\"signed_creds\":\"GHI\",\"tokens\":\"ABC\"},\"expires_at\":\"2\",\"id\":\"1234\",\"legacy_claimed\":false,\"public_keys\":\"5678\",\"status\":-1,\"suggestions\":1,\"type\":1,\"version\":1}"; // NOLINT + + ledger::PromotionPtr promotion = FromStringToPromotion(promotion_as_string); + + EXPECT_EQ(promotion->status, ledger::PromotionStatus::UNKNOWN); +} + +} // namespace braveledger_bind_util diff --git a/vendor/bat-native-ledger/src/bat/ledger/internal/common/security_helper_unittest.cc b/vendor/bat-native-ledger/src/bat/ledger/internal/common/security_helper_unittest.cc new file mode 100644 index 000000000000..bf3e2c959005 --- /dev/null +++ b/vendor/bat-native-ledger/src/bat/ledger/internal/common/security_helper_unittest.cc @@ -0,0 +1,137 @@ +/* Copyright (c) 2019 The Brave Authors. All rights reserved. + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include +#include +#include +#include + +#include "bat/ledger/internal/common/security_helper.h" + +#include "testing/gtest/include/gtest/gtest.h" + +// npm run test -- brave_unit_tests --filter=SecurityHelper* + +namespace braveledger_helper { + +class SecurityHelperTest : public ::testing::Test { + protected: + SecurityHelperTest() { + // You can do set-up work for each test here + } + + ~SecurityHelperTest() override { + // You can do clean-up work that doesn't throw exceptions here + } +}; + +TEST_F(SecurityHelperTest, Sign) { + // Arrange + std::map header = { + {"digest", "SHA-256=qj7EBzMRSsGh4Rfu8Zha6MvPB2WftfJNeF8gt7hE9AY="} + }; + std::vector> headers; + headers.push_back(header); + + std::string key_id = "primary"; + + std::vector private_key = { + 0xe9, 0xb1, 0xab, 0x4f, 0x44, 0xd3, 0x9e, 0xb0, 0x43, 0x23, 0x41, 0x1e, + 0xed, 0x0b, 0x5a, 0x2c, 0xee, 0xdf, 0xf0, 0x12, 0x64, 0x47, 0x4f, 0x86, + 0xe2, 0x9c, 0x70, 0x7a, 0x56, 0x61, 0x56, 0x50, 0x33, 0xce, 0xa0, 0x08, + 0x5c, 0xfd, 0x55, 0x1f, 0xaa, 0x17, 0x0c, 0x1d, 0xd7, 0xf6, 0xda, 0xaa, + 0x90, 0x3c, 0xdd, 0x31, 0x38, 0xd6, 0x1e, 0xd5, 0xab, 0x28, 0x45, 0xe2, + 0x24, 0xd5, 0x81, 0x44 + }; + + // Act + auto signature = Security::Sign(headers, key_id, private_key); + + // Assert + std::string expected_signature = R"(keyId="primary",algorithm="ed25519",headers="digest",signature="hD1v796rnnvTaW5poFQ+Wl+o/C9HrR/WEjODGlszANIdEjjYVPgtm8aCRYVNXkXhDNgCehVKxrHwZgNKqe8lDg==")"; // NOLINT + EXPECT_EQ(expected_signature, signature); +} + +TEST_F(SecurityHelperTest, Sign_InvalidPublicKey) { + // Arrange + std::map header = { + {"digest", "SHA-256=qj7EBzMRSsGh4Rfu8Zha6MvPB2WftfJNeF8gt7hE9AY="} + }; + std::vector> headers; + headers.push_back(header); + + std::string key_id = "primary"; + + std::vector private_key = { + 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, + 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, + 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, + 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, + 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, + 0xde, 0xad, 0xbe, 0xef + }; + + // Act + auto signature = Security::Sign(headers, key_id, private_key); + + // Assert + std::string expected_signature = "m5CxS9uqI7DbZ5UDo51bcLRP2awqcUSU8tfc4t/ysrH47B8OJUG1roQyi6/pjSZj9VJuj296v77c/lxBlCn2DA=="; // NOLINT + EXPECT_NE(expected_signature, signature); +} + +TEST_F(SecurityHelperTest, GenerateTokens) { + // Arrange + + // Act + auto tokens = Security::GenerateTokens(5); + + // Assert + auto count = tokens.size(); + EXPECT_EQ(5UL, count); +} + +TEST_F(SecurityHelperTest, BlindTokens) { + // Arrange + auto tokens = Security::GenerateTokens(7); + + // Act + auto blinded_tokens = Security::BlindTokens(tokens); + + // Assert + EXPECT_EQ(tokens.size(), blinded_tokens.size()); +} + +TEST_F(SecurityHelperTest, GetSHA256) { + // Arrange + std::string body = R"({"blindedTokens":["iiafV6PGoG+Xz6QR+k1WaYllcA+w0a1jcDqhbpFbvWw=","8g7v9CDoZuOjnABr8SYUJmCIRHlwkFpFBB6rLfEJlz0=","chNIADY97/IiLfWrE/P5T3p3SQIPZAc4fKkB8/4byHE=","4nW47xQoQB4+uEz3i6/sbb+FDozpdiOTG53E+4RJ9kI=","KO9qa7ZuGosA2xjM2+t3rn7/7Oljga6Ak1fgixjtp2U=","tIBcIB2Xvmx0S+2jwcYrnzPvf20GTconlWDSiWHqR3g=","aHtan+UcZF0II/SRoYm7bK27VJWDabNKjXKSVaoPPTY=","6jggPJK8NL1AedlRpJSrCC3+reG2BMGqHOmIPtAsmwA=","7ClK9P723ff+dOZxOZ0jSonmI5AHqsQU2Cn8FVAHID4=","zkm+vIFM0ko74m+XhnZirCh7YUc9ucDtQTC+kwhWvzQ=","+uoLhdsMEg42PRYiLs0lrAiGcmsPWX2D6hxmrcLUgC8=","GNE2ISRb52HSPq0maJ9YXmbbkzUpo5dSNIM9I1eD+F4=","iBx49OAb3LWQzKko8ZeVVAkwdSKRbDHViqR6ciBICCw=","IBC208b0z56kzjG2Z/iTwriZfMp2cqoQgk4vyJAKJy8=","Vq4l6jx8vSCmvTVFMg3Wz04Xz/oomFq4QRt26vRhDWg=","5KIAJPFrSrVW92FJXP7WmHLc7d5a4lfTrXTRKC9rYQg=","/s/SELS2gTDt1Rt7XaJ54RaGLQUL85cLpKW2mBLU2HU=","HkJpt3NbymO56XbB2Tj4S4xyIKSjltFTjn1QdC1rLnM=","/CQIGwgHAX2kFmaJ+65YtAbO4eSfUvMojVxZLq/p/AE=","8N33oYwImtxf9rbrAQ1v8VlRD4iHDVR11yhYCKKKGFs=","6EjTK0lYDGwFPrtMyTjiYIPV4OK7beMBTV6qrgFCwDw=","5LzZynN+sxbIfQKc92V3dC82x4e99oxChk7fFNvJHmM=","uEW1D0SU8VU5UGPOnkrCv3I+NFNa1fNPSjDy4gjvIm0=","aIEvt2dBwTp1vuxNYjLaP25YdV3FjCG23NDxZG+MXxg=","DIhrKTcba0NNoEKQAsSb1t9R3KVrkwX8fpLlOOLcMkI=","vNaRbm7RPEkFvNNdLKaNhyd7gkM+kNt23G0N4sLnLhU=","4MXZ/1hM6+xVzyYWY14tjIxCaisfrTgAUD3LLJHSd14=","6hsMVd3VIjKUhHmHQRQRKr7duSiKzL36b/J+Mc4DPHM=","OCe1Vv0l86izNn1PHw+yLw5e37J/Ab3oVyTPgFlS4Wc=","hu5fi5YMxsWfmK3uTspjcjwguBDeiYMGuV+vIzC8jlg=","Vs+EZRjtF+xUC3sYUZsvpND8ugLPz6Yl0jCcv4HO2Co=","7Pxgek1VUU+93o6PWUdKgQW7IkDmLsotSEg8H7xj93U=","avRL8coOl6cWJxKlvY9mHfw1FWIF14JnhNdxW00fqAM=","Vvo4hscwrZgOIuwkgUaxzyrcGQbUS1vCWcNgjEkhfUg=","ChsgA1m1hmWFt3r6xQqNCZVqx/tMMzEdpy++uccB3Cs=","MImbGYf4TyE9WW/jx381Spk0B9boASAyehwz1om9Ong=","ksPN5jCF2uN8d1io+xXVJhJXZs/DpQsPsoCZl8L9EgA=","4AApGEJLMC3rgYgUABQp9nTXeikDmS29a2wkUOXIQXU=","JOcObac9kXq8eD0aIU5S5DKWiA/Ggf4tBC58KD2xtRs=","CBHMKoOwelZhfmupH1bH5Yo6BxDSkT8G2Jfk4xKsgyU=","Al/1AAI4W68MEk6+Ay0xIGjxzvlX6IdnPV9KgO1RU0c=","MtKvUJzIOOvOw8y+XzBbUrgyPxvE/DID2qvB3VsmVEs=","oIaCqLv0kIG9BDZz5u0xj0/ZQqZQMCn7gkgIHVioSFc=","8N1j1xiNm8dY90J9HQaeKyG861i2AN0w9nkF4cieZzw=","wDMa7tUhloYanmLOivcgHyjCLr/OMaKtWdqbhadEmRM=","bCquxc5v8J/P2pqay5fpzcLkTqSVvwdZrAbbIOF8Lhs=","ODPBJiCcOMv48YS9QIcD0dH4bsfD2zQVsWkwBef1ci4=","eA9Yt1HOkDNvDT6+kq0093d7WI/L78/Gj9nAlmSYwzE=","wqt3REJpnoxOCSdHcJEiOsdBWb5yQD5jaTahFz40Tkc=","tLdemf03DyE7OkTS8QCZS8OT0JflCVO1CmCbA8i2SXI="]})"; // NOLINT + + // Act + auto actual_sha256 = Security::GetSHA256(body); + + // Assert + std::vector expected_sha256 = { '\xAA', '>', '\xC4', '\a', '3', + '\x11', 'J', '\xC1', '\xA1', '\xE1', '\x17', '\xEE', '\xF1', '\x98', + 'Z', '\xE8', '\xCB', '\xCF', '\a', 'e', '\x9F', '\xB5', '\xF2', 'M', + 'x', '_', ' ', '\xB7', '\xB8', 'D', '\xF4', '\x6'}; + EXPECT_EQ(expected_sha256, actual_sha256); +} + +TEST_F(SecurityHelperTest, GetBase64) { + // Arrange + std::vector sha256 = { '\xAA', '>', '\xC4', '\a', '3', + '\x11', 'J', '\xC1', '\xA1', '\xE1', '\x17', '\xEE', '\xF1', '\x98', + 'Z', '\xE8', '\xCB', '\xCF', '\a', 'e', '\x9F', '\xB5', '\xF2', 'M', + 'x', '_', ' ', '\xB7', '\xB8', 'D', '\xF4', '\x6'}; + + // Act + auto actual_sha256_base64 = Security::GetBase64(sha256); + + // Assert + std::string expected_sha256_base64 = + "qj7EBzMRSsGh4Rfu8Zha6MvPB2WftfJNeF8gt7hE9AY="; + EXPECT_EQ(expected_sha256_base64, actual_sha256_base64); +} + +} // namespace braveledger_helper diff --git a/vendor/bat-native-ledger/src/bat/ledger/internal/ledger_impl.h b/vendor/bat-native-ledger/src/bat/ledger/internal/ledger_impl.h index 33bd791f69a3..d7aace83424c 100644 --- a/vendor/bat-native-ledger/src/bat/ledger/internal/ledger_impl.h +++ b/vendor/bat-native-ledger/src/bat/ledger/internal/ledger_impl.h @@ -199,7 +199,7 @@ class LedgerImpl : public ledger::Ledger, void OnWalletInitializedInternal(ledger::Result result, ledger::InitializeCallback callback); - void OnWalletProperties(ledger::Result result, + virtual void OnWalletProperties(ledger::Result result, const ledger::WalletProperties&); void FetchWalletProperties( @@ -363,7 +363,7 @@ class LedgerImpl : public ledger::Ledger, void SetPreFlight(const std::string& pre_flight); - const ledger::WalletInfoProperties& GetWalletInfo() const; + virtual const ledger::WalletInfoProperties& GetWalletInfo() const; void SetWalletInfo(const ledger::WalletInfoProperties& info); @@ -417,7 +417,7 @@ class LedgerImpl : public ledger::Ledger, const ledger::PublisherInfoList* list, uint32_t /* next_record */); - void SetTimer(uint64_t time_offset, uint32_t* timer_id) const; + virtual void SetTimer(uint64_t time_offset, uint32_t* timer_id) const; bool AddReconcileStep(const std::string& viewing_id, ledger::ContributionRetry step, diff --git a/vendor/bat-native-ledger/src/bat/ledger/internal/ledger_impl_mock.h b/vendor/bat-native-ledger/src/bat/ledger/internal/ledger_impl_mock.h index 0a99c05e94d6..308d55f33cd1 100644 --- a/vendor/bat-native-ledger/src/bat/ledger/internal/ledger_impl_mock.h +++ b/vendor/bat-native-ledger/src/bat/ledger/internal/ledger_impl_mock.h @@ -185,14 +185,6 @@ class MockLedgerImpl : public LedgerImpl { MOCK_METHOD3(OnRecoverWallet, void(const ledger::Result, double, ledger::RecoverWalletCallback)); - MOCK_METHOD6(LoadURL, - void(const std::string&, - const std::vector&, - const std::string&, - const std::string&, - const ledger::UrlMethod, - ledger::LoadURLCallback)); - MOCK_METHOD5(ReconcileComplete, void(ledger::Result, const double, diff --git a/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion.cc b/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion.cc index f89c474224c3..51fe5a4cbc36 100644 --- a/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion.cc +++ b/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion.cc @@ -420,7 +420,8 @@ void Promotion::Retry(ledger::PromotionMap promotions) { } case ledger::PromotionStatus::ACTIVE: case ledger::PromotionStatus::FINISHED: - case ledger::PromotionStatus::OVER: { + case ledger::PromotionStatus::OVER: + case ledger::PromotionStatus::UNKNOWN: { break; } } @@ -918,4 +919,14 @@ void Promotion::TransferTokens( transfer_->Start(std::move(wallet), callback); } +void Promotion::SetLastCheckTimerIdForTesting( + uint32_t timer_id) { + last_check_timer_id_ = timer_id; +} + +void Promotion::SetRetryTimerIdForTesting( + uint32_t timer_id) { + retry_timer_id_ = timer_id; +} + } // namespace braveledger_promotion diff --git a/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion.h b/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion.h index 5caf960a4c2e..f3ac3e05ed85 100644 --- a/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion.h +++ b/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion.h @@ -52,6 +52,8 @@ class Promotion { void TransferTokens( ledger::ExternalWalletPtr wallet, ledger::ResultCallback callback); + void SetLastCheckTimerIdForTesting(uint32_t timer_id); + void SetRetryTimerIdForTesting(uint32_t timer_id); private: void OnFetch( diff --git a/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion_unittest.cc b/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion_unittest.cc index 6cfa62396733..972fec4f3947 100644 --- a/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion_unittest.cc +++ b/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion_unittest.cc @@ -13,7 +13,7 @@ #include "bat/ledger/internal/ledger_client_mock.h" #include "bat/ledger/internal/ledger_impl_mock.h" #include "bat/ledger/internal/promotion/promotion.h" -#include "bat/ledger/ledger.h" +#include "bat/ledger/internal/state_keys.h" #include "testing/gtest/include/gtest/gtest.h" // npm run test -- brave_unit_tests --filter=PromotionTest.* @@ -65,31 +65,259 @@ class PromotionTest : public testing::Test { std::make_unique(mock_ledger_client_.get()); promotion_ = std::make_unique(mock_ledger_impl_.get()); } +}; + +TEST_F(PromotionTest, TestInitialize) { + // Arrange + ON_CALL(*mock_ledger_client_, GetBooleanState( + ledger::kStatePromotionCorruptedMigrated)) + .WillByDefault(testing::Return(false)); + + EXPECT_CALL(*mock_ledger_impl_, GetAllPromotions(_)).Times(2); + + // Act + promotion_->Initialize(); + + // Assert + // See |EXPECT_CALL| in arrange, as this must happen before Act +} + +TEST_F(PromotionTest, TestInitializeWithCorruptedPromotionMigration) { + // Arrange + ON_CALL(*mock_ledger_client_, GetBooleanState( + ledger::kStatePromotionCorruptedMigrated)) + .WillByDefault(testing::Return(true)); + + EXPECT_CALL(*mock_ledger_impl_, GetAllPromotions(_)); + + // Act + promotion_->Initialize(); + + // Assert + // See |EXPECT_CALL| in arrange, as this must happen before Act +} + +// void Fetch(ledger::FetchPromotionCallback callback); + +TEST_F(PromotionTest, TestFetchWithNoWalletPaymentID) { + // Arrange + EXPECT_CALL(*mock_ledger_impl_, + OnWalletProperties(ledger::Result::CORRUPTED_WALLET, _)); + const std::string payment_id = ""; + ON_CALL(*mock_ledger_impl_, GetPaymentId()) + .WillByDefault(testing::ReturnRef(payment_id)); + const std::string wallet_passphrase = "bob"; + ON_CALL(*mock_ledger_impl_, GetWalletPassphrase()) + .WillByDefault(testing::Return(wallet_passphrase)); + + bool callback_called = false; + + ledger::FetchPromotionCallback fetch_promotion_callback = + std::bind( + [&callback_called](ledger::Result result, + ledger::PromotionList promotions) { + callback_called = true; + EXPECT_EQ(result, ledger::Result::CORRUPTED_WALLET); + }, + _1, _2); + + // Act + promotion_->Fetch(fetch_promotion_callback); + + // Assert + EXPECT_TRUE(callback_called); +} + +TEST_F(PromotionTest, TestFetchWithNoWalletPassphrase) { + // Arrange + EXPECT_CALL(*mock_ledger_impl_, + OnWalletProperties(ledger::Result::CORRUPTED_WALLET, _)); + const std::string payment_id = "bob"; + ON_CALL(*mock_ledger_impl_, GetPaymentId()) + .WillByDefault(testing::ReturnRef(payment_id)); + const std::string wallet_passphrase = ""; + ON_CALL(*mock_ledger_impl_, GetWalletPassphrase()) + .WillByDefault(testing::Return(wallet_passphrase)); + + bool callback_called = false; + + ledger::FetchPromotionCallback fetch_promotion_callback = + std::bind( + [&callback_called](ledger::Result result, + ledger::PromotionList promotions) { + callback_called = true; + EXPECT_EQ(result, ledger::Result::CORRUPTED_WALLET); + }, + _1, _2); + + // Act + promotion_->Fetch(fetch_promotion_callback); + + // Assert + EXPECT_TRUE(callback_called); +} + +TEST_F(PromotionTest, TestFetch) { + // Arrange + EXPECT_CALL(*mock_ledger_client_, LoadURL(_, _, _, _, _, _)); + + const std::string payment_id = "bob"; + ON_CALL(*mock_ledger_impl_, GetPaymentId()) + .WillByDefault(testing::ReturnRef(payment_id)); + + const std::string wallet_passphrase = "fred"; + ON_CALL(*mock_ledger_impl_, GetWalletPassphrase()) + .WillByDefault(testing::Return(wallet_passphrase)); + + ledger::FetchPromotionCallback fetch_promotion_callback = + std::bind( + [&](ledger::Result result, + ledger::PromotionList promotions) { + }, + _1, _2); + + // Act + promotion_->Fetch(fetch_promotion_callback); +} + +// void Claim( +// const std::string& payload, +// ledger::ClaimPromotionCallback callback); +// SUCCESS: Expect call Promotion::OnCompletedAttestation +// Nb. Needs a mock on AttestationImpl but cannot inject for testing + +// void Attest( +// const std::string& promotion_id, +// const std::string& solution, +// ledger::AttestPromotionCallback callback); +// Nb. Needs a mock on AttestationImpl but cannot inject for testing + +// void Refresh(const bool retry_after_error); +TEST_F(PromotionTest, TestRefreshWithoutRetryWithTimerId) { + // Arrange + EXPECT_CALL(*mock_ledger_impl_, SetTimer(_, _)).Times(0); + + promotion_->SetLastCheckTimerIdForTesting(1); + + // Act + promotion_->Refresh(false); +} + +TEST_F(PromotionTest, TestRefreshWithRetryWithTimerId) { + // Arrange + EXPECT_CALL(*mock_ledger_impl_, SetTimer(_, _)).Times(0); + + promotion_->SetLastCheckTimerIdForTesting(1); + + // Act + promotion_->Refresh(true); +} + +TEST_F(PromotionTest, TestRefreshWithoutRetryOrTimerId) { + // Arrange + EXPECT_CALL(*mock_ledger_impl_, SetTimer(_, _)).Times(1); + + promotion_->SetLastCheckTimerIdForTesting(0); + + // Act + promotion_->Refresh(false); +} + +TEST_F(PromotionTest, TestRefreshWithRetryWithoutTimerId) { + // Arrange + EXPECT_CALL(*mock_ledger_impl_, SetTimer(_, _)).Times(1); +// calls ledger_->SetTimer with start_timer_in as a random value (how to test?) + + promotion_->SetLastCheckTimerIdForTesting(0); + + // Act + promotion_->Refresh(true); +} + +// void OnTimer(const uint32_t timer_id); +// Nb. Cannot test without mocking Promotion +// discussed with tmancey and no value as code may be changing +// need to confirm with nejc +// SUCCESS: timer_id == last_check_timer_id_; +// - expect call Fetch +// - last_check_timer_id_ = 0 +// SUCCESS: timer_id == retry_timer_id_; +// - expect call ledger_->GetAllPromotions +// OR expect call Promotion::Retry +// FAIL: timer_id != (last_check_timer_id_ or retry_timer_id_) +// - neither expected (above) to be called + + +// void ClaimTokens( +// ledger::PromotionPtr promotion, +// ledger::ResultCallback callback); +TEST_F(PromotionTest, TestClaimTokensWithNullPromotion) { + // Arrange + bool callback_called = false; + ledger::ResultCallback callback = + std::bind( + [&callback_called](ledger::Result result) { + callback_called = (result == ledger::Result::LEDGER_ERROR); + }, _1); + + // Act + promotion_->ClaimTokens(nullptr, callback); + + // Assert + EXPECT_TRUE(callback_called); +} + +TEST_F(PromotionTest, TestClaimTokensWithPromotion) { + // Arrange + bool callback_called = false; + + ledger::PromotionPtr promotion = ledger::Promotion::New(); + promotion->id = "ABC123"; + promotion->suggestions = 1; + + ledger::ResultCallback callback = + std::bind( + [&callback_called](ledger::Result result) { + callback_called = true; + }, _1); + + const std::string payment_id = "bob"; + ON_CALL(*mock_ledger_impl_, GetPaymentId()) + .WillByDefault(testing::ReturnRef(payment_id)); + + ledger::WalletInfoProperties wallet_info; + wallet_info.key_info_seed.push_back(1); + ON_CALL(*mock_ledger_impl_, GetWalletInfo()) + .WillByDefault(testing::ReturnRef(wallet_info)); + + // Act + promotion_->ClaimTokens(promotion.Clone(), callback); + + // Assert + EXPECT_FALSE(callback_called); +} - void SetUp() override { - const std::string payment_id = "this_is_id"; - ON_CALL(*mock_ledger_impl_, GetPaymentId()) +TEST_F(PromotionTest, LegacyPromotionIsNotOverwritten) { + const std::string payment_id = "this_is_id"; + ON_CALL(*mock_ledger_impl_, GetPaymentId()) .WillByDefault(testing::ReturnRefOfCopy(payment_id)); - const std::string wallet_passphrase = "phrase"; - ON_CALL(*mock_ledger_impl_, GetWalletPassphrase()) + const std::string wallet_passphrase = "phrase"; + ON_CALL(*mock_ledger_impl_, GetWalletPassphrase()) .WillByDefault(testing::Return(wallet_passphrase)); - ON_CALL(*mock_ledger_impl_, LoadURL(_, _, _, _, _, _)) + ON_CALL(*mock_ledger_client_, LoadURL(_, _, _, _, _, _)) .WillByDefault( - Invoke([]( - const std::string& url, - const std::vector& headers, - const std::string& content, - const std::string& contentType, - const ledger::UrlMethod method, - ledger::LoadURLCallback callback) { - callback(200, GetResponse(url), {}); - })); - } -}; + Invoke([]( + const std::string& url, + const std::vector& headers, + const std::string& content, + const std::string& contentType, + const ledger::UrlMethod method, + ledger::LoadURLCallback callback) { + callback(200, GetResponse(url), {}); + })); -TEST_F(PromotionTest, LegacyPromotionIsNotOverwritten) { ledger::FetchPromotionCallback fetch_promotion_callback = std::bind( [&](ledger::Result result, @@ -124,5 +352,4 @@ TEST_F(PromotionTest, LegacyPromotionIsNotOverwritten) { promotion_->Fetch(fetch_promotion_callback); } - } // namespace braveledger_promotion diff --git a/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion_util_unittest.cc b/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion_util_unittest.cc index 3cd1c6cdef18..92a529b77726 100644 --- a/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion_util_unittest.cc +++ b/vendor/bat-native-ledger/src/bat/ledger/internal/promotion/promotion_util_unittest.cc @@ -157,4 +157,448 @@ TEST_F(PromotionUtilTest, UnBlindTokensCredsNotCorrect) { EXPECT_EQ(unblinded_encoded_tokens.size(), 0u); } +// std::string ParseOSToString(ledger::OperatingSystem os) + +TEST_F(PromotionUtilTest, ParseOSToStringForWindows) { + // Act + const std::string os_string = + ParseOSToString(ledger::OperatingSystem::WINDOWS); + + // Assert + EXPECT_EQ(os_string, "windows"); +} + +TEST_F(PromotionUtilTest, ParseOSToStringForMacOS) { + // Act + const std::string os_string = + ParseOSToString(ledger::OperatingSystem::MACOS); + + // Assert + EXPECT_EQ(os_string, "osx"); +} + +TEST_F(PromotionUtilTest, ParseOSToStringForLinux) { + // Act + const std::string os_string = + ParseOSToString(ledger::OperatingSystem::LINUX); + + // Assert + EXPECT_EQ(os_string, "linux"); +} + +TEST_F(PromotionUtilTest, ParseOSToStringForUndefined) { + // Act + const std::string os_string = + ParseOSToString(ledger::OperatingSystem::UNDEFINED); + + // Assert + EXPECT_EQ(os_string, "undefined"); +} + +// std::string ParseClientInfoToString(ledger::ClientInfoPtr info) + +TEST_F(PromotionUtilTest, ParseClientInfoToStringForAndroid) { + // Arrange + auto client_info = ledger::ClientInfo::New(); + client_info->platform = ledger::Platform::ANDROID_R; + + // Act + const std::string client_info_string = + ParseClientInfoToString(std::move(client_info)); + + // Assert + EXPECT_EQ(client_info_string, "android"); +} + +TEST_F(PromotionUtilTest, ParseClientInfoToStringForIos) { + // Arrange + auto client_info = ledger::ClientInfo::New(); + client_info->platform = ledger::Platform::IOS; + + // Act + const std::string client_info_string = + ParseClientInfoToString(std::move(client_info)); + + // Assert + EXPECT_EQ(client_info_string, "ios"); +} + +TEST_F(PromotionUtilTest, ParseClientInfoToStringForDesktop) { + // Arrange + auto client_info = ledger::ClientInfo::New(); + client_info->platform = ledger::Platform::DESKTOP; + client_info->os = ledger::OperatingSystem::WINDOWS; + + // Act + const std::string client_info_string = + ParseClientInfoToString(std::move(client_info)); + + // Assert + EXPECT_EQ(client_info_string, "windows"); +} + +TEST_F(PromotionUtilTest, ParseClientInfoToStringWithNullptr) { + // Act + const std::string client_info_string = ParseClientInfoToString(nullptr); + + // Assert + EXPECT_EQ(client_info_string, ""); +} + +// ledger::PromotionType ConvertStringToPromotionType(const std::string& type) + +TEST_F(PromotionUtilTest, ConvertStringToPromotionTypeForUGP) { + // Act + const ledger::PromotionType promotion_type = + ConvertStringToPromotionType("ugp"); + + // Assert + EXPECT_EQ(promotion_type, ledger::PromotionType::UGP); +} + +TEST_F(PromotionUtilTest, ConvertStringToPromotionTypeForADS) { + // Act + const ledger::PromotionType promotion_type = + ConvertStringToPromotionType("ads"); + + // Assert + EXPECT_EQ(promotion_type, ledger::PromotionType::ADS); +} + +// ledger::ReportType ConvertPromotionTypeToReportType( +// const ledger::PromotionType type) + +TEST_F(PromotionUtilTest, ConvertPromotionTypeToReportTypeForUGP) { + // Act + ledger::ReportType report_type = + ConvertPromotionTypeToReportType(ledger::PromotionType::UGP); + + // Assert + EXPECT_EQ(report_type, ledger::ReportType::GRANT_UGP); +} + +TEST_F(PromotionUtilTest, ConvertPromotionTypeToReportTypeForADS) { + // Act + ledger::ReportType report_type = + ConvertPromotionTypeToReportType(ledger::PromotionType::ADS); + + // Assert + EXPECT_EQ(report_type, ledger::ReportType::GRANT_AD); +} + +// bool ParseFetchResponse( +// const std::string& response, +// ledger::PromotionList* list) + +TEST_F(PromotionUtilTest, ParseFetchResponseWithNullptrList) { + std::string response; + + // Act + bool success = ParseFetchResponse(response, nullptr); + + // Assert + EXPECT_FALSE(success); +} + +TEST_F(PromotionUtilTest, ParseFetchResponseWithNoResponseContent) { + std::string response; + ledger::PromotionList list; + + // Act + bool success = ParseFetchResponse(response, &list); + + // Assert + EXPECT_FALSE(success); +} + +TEST_F(PromotionUtilTest, ParseFetchResponseWithInvalidResponseContent) { + std::string response = "qwertyuyiuoip"; + ledger::PromotionList list; + + // Act + bool success = ParseFetchResponse(response, &list); + + // Assert + EXPECT_FALSE(success); +} + +TEST_F(PromotionUtilTest, ParseFetchResponseWithCompletePromotion) { + const std::string response = R"({"promotions":[{"id":"1234","type":"ugp","version":1,"available":false,"approximateValue":"100.000000","legacyClaimed":false,"expiresAt":"2","publicKeys":["\"ABC\""],"suggestionsPerGrant":1}]})"; // NOLINT + ledger::PromotionList promotion_list; + + // Act + bool success = ParseFetchResponse(response, &promotion_list); + + // Assert + EXPECT_TRUE(success); + + EXPECT_EQ(promotion_list.size(), static_cast(1)); + + for (auto& promotion : promotion_list) { + EXPECT_EQ(promotion->id, "1234"); + } +} + +TEST_F(PromotionUtilTest, ParseFetchResponseWithCompletePromotions) { + const std::string response = R"({"promotions":[{"id":"1234","type":"ugp","version":1,"available":false,"approximateValue":"100.000000","legacyClaimed":false,"expiresAt":"2","publicKeys":["\"ABC\""],"suggestionsPerGrant":1},{"id":"5678","type":"ugp","version":1,"available":false,"approximateValue":"100.000000","legacyClaimed":false,"expiresAt":"2","publicKeys":["\"ABC\""],"suggestionsPerGrant":1}]})"; // NOLINT + ledger::PromotionList promotion_list; + + // Act + bool success = ParseFetchResponse(response, &promotion_list); + + // Assert + EXPECT_TRUE(success); + + EXPECT_EQ(promotion_list.size(), static_cast(2)); + + bool found_promotion_a = false; + bool found_promotion_b = false; + + for (auto& promotion : promotion_list) { + if (promotion->id == "1234") { + found_promotion_a = true; + } else if (promotion->id == "5678") { + found_promotion_b = true; + } + } + EXPECT_TRUE(found_promotion_a); + EXPECT_TRUE(found_promotion_b); +} + +TEST_F(PromotionUtilTest, + ParseFetchResponseWithCompleteAndIncompletePromotions) { + // Arrange + const std::string response = R"({"promotions":[{"id":"1234","type":"ugp","version":1,"available":false,"approximateValue":"100.000000","legacyClaimed":false,"expiresAt":"2","publicKeys":["\"ABC\""],"suggestionsPerGrant":1},{"id":"5678","type":"ugp","version":1,"available":false,"approximateValue":"100.000000","legacyClaimed":false,"expiresAt":"2","publicKeys":["\"ABC\""]}]})"; // NOLINT + // Nb. Promotion ID "5678" is missing "suggestionsPerGrant" + ledger::PromotionList promotion_list; + + // Act + bool success = ParseFetchResponse(response, &promotion_list); + + // Assert + EXPECT_FALSE(success); + + EXPECT_EQ(promotion_list.size(), static_cast(1)); + + for (auto& promotion : promotion_list) { + EXPECT_EQ(promotion->id, "1234"); + } +} + +// std::string ParseClaimTokenResponse( +// const std::string& response); + +TEST_F(PromotionUtilTest, ParseClaimTokenResponseWithNoContent) { + // Arrange + const std::string response = ""; + + // Act + const std::string claim_token = ParseClaimTokenResponse(response); + + // Assert + EXPECT_EQ(claim_token, ""); +} + +TEST_F(PromotionUtilTest, ParseClaimTokenResponseWithInvalidContent) { + // Arrange + const std::string response = R"({"bob":"1234"})"; + + // Act + const std::string claim_token = ParseClaimTokenResponse(response); + + // Assert + EXPECT_EQ(claim_token, ""); +} + +TEST_F(PromotionUtilTest, ParseClaimTokenResponseWithValidContent) { + // Arrange + const std::string response = R"({"claimId":"1234"})"; + + // Act + const std::string claim_token = ParseClaimTokenResponse(response); + + // Assert + EXPECT_EQ(claim_token, "1234"); +} + +// void ParseSignedTokensResponse( + // const std::string& response, + // base::Value* result); + +TEST_F(PromotionUtilTest, ParseSignedTokensResponseWithNoContent) { + // Arrange + const std::string response = ""; + base::Value parsed_response(base::Value::Type::DICTIONARY); + + // Act + ParseSignedTokensResponse(response, &parsed_response); + + // Assert + EXPECT_EQ(parsed_response.DictSize(), static_cast(0)); +} + +/* TODO(masparrow): fix crash! +TEST_F(PromotionUtilTest, + ParseSignedTokensResponseWithValidContentButNoResponseObject) { + // Arrange + const std::string response = R"({"batchProof":"1234","publicKey":"ABCD","signedCreds":["ABC"]})"; // NOLINT + + // Act + ParseSignedTokensResponse(response, nullptr); + + // Assert + EXPECT_TRUE(true); // TODO(masparrow): Not sure how to qualify this test? +} +*/ +TEST_F(PromotionUtilTest, ParseSignedTokensResponseMissingBatchProof) { + // Arrange + const std::string response = R"({"publicKey":"ABCD","signedCreds":["ABC"]})"; // NOLINT + base::Value parsed_response(base::Value::Type::DICTIONARY); + + // Act + ParseSignedTokensResponse(response, &parsed_response); + + // Assert + EXPECT_EQ(parsed_response.DictSize(), static_cast(0)); +} + +TEST_F(PromotionUtilTest, ParseSignedTokensResponseMissingPublicKey) { + // Arrange + const std::string response = R"({"batchProof":"1234","signedCreds":["ABC"]})"; // NOLINT + base::Value parsed_response(base::Value::Type::DICTIONARY); + + // Act + ParseSignedTokensResponse(response, &parsed_response); + + // Assert + EXPECT_EQ(parsed_response.DictSize(), static_cast(0)); +} + +TEST_F(PromotionUtilTest, ParseSignedTokensResponseMissingSignedCreds) { + // Arrange + const std::string response = R"({"batchProof":"1234","publicKey":"ABCD"})"; // NOLINT + base::Value parsed_response(base::Value::Type::DICTIONARY); + + // Act + ParseSignedTokensResponse(response, &parsed_response); + + // Assert + EXPECT_EQ(parsed_response.DictSize(), static_cast(0)); +} + +TEST_F(PromotionUtilTest, ParseSignedTokensResponseEmptySignedCreds) { + // Arrange + const std::string response = R"({"batchProof":"1234","publicKey":"ABCD","signedCreds":[]})"; // NOLINT + base::Value parsed_response(base::Value::Type::DICTIONARY); + + // Act + ParseSignedTokensResponse(response, &parsed_response); + + // Assert + EXPECT_EQ(parsed_response.DictSize(), static_cast(3)); + base::Value* signed_creds_value = parsed_response.FindListKey("signed_creds"); + EXPECT_TRUE(signed_creds_value != nullptr); + base::Value::ListStorage& signed_creds = signed_creds_value->GetList(); + EXPECT_EQ(signed_creds.size(), static_cast(0)); +} + +TEST_F(PromotionUtilTest, ParseSignedTokensResponseWithValidContent) { + // Arrange + const std::string response = R"({"batchProof":"1234","publicKey":"ABCD","signedCreds":["ABC"]})"; // NOLINT + base::Value parsed_response(base::Value::Type::DICTIONARY); + + // Act + ParseSignedTokensResponse(response, &parsed_response); + + // Assert + EXPECT_EQ(parsed_response.DictSize(), static_cast(3)); + + base::Value* signed_creds_value = parsed_response.FindListKey("signed_creds"); + EXPECT_TRUE(signed_creds_value != nullptr); + base::Value::ListStorage& signed_creds = signed_creds_value->GetList(); + EXPECT_EQ(signed_creds.size(), static_cast(1)); + base::Value& signed_cred_value = signed_creds.front(); + const std::string& signed_cred = signed_cred_value.GetString(); + EXPECT_EQ(signed_cred, "ABC"); + + const std::string* public_key = parsed_response.FindStringKey("public_key"); + EXPECT_TRUE(public_key != nullptr); + EXPECT_EQ(*public_key, "ABCD"); + + const std::string* batch_proof = parsed_response.FindStringKey("batch_proof"); + EXPECT_TRUE(batch_proof != nullptr); + EXPECT_EQ(*batch_proof, "1234"); +} + +// std::unique_ptr ParseStringToBaseList( +// const std::string& string_list); + +// bool VerifyPublicKey(const ledger::PromotionPtr promotion) + +TEST_F(PromotionUtilTest, VerifyPublicKeyWithNullptr) { + // Arrange + auto promotion = ledger::Promotion::New(); + promotion->credentials = ledger::PromotionCreds::New(); + + // Act + bool result = braveledger_promotion::VerifyPublicKey(nullptr); + + // Assert + EXPECT_EQ(result, false); +} + +TEST_F(PromotionUtilTest, VerifyPublicKeyWithoutCredentials) { + // Arrange + auto promotion = ledger::Promotion::New(); + promotion->credentials = ledger::PromotionCreds::New(); + + // Act + bool result = braveledger_promotion::VerifyPublicKey(promotion->Clone()); + + // Assert + EXPECT_EQ(result, false); +} + +TEST_F(PromotionUtilTest, VerifyPublicKeyWithInvalidKeys) { + // Arrange + auto promotion = ledger::Promotion::New(); + promotion->credentials = ledger::PromotionCreds::New(); + promotion->public_keys = "fdsfsdds"; + + // Act + bool result = braveledger_promotion::VerifyPublicKey(promotion->Clone()); + + // Assert + EXPECT_EQ(result, false); +} + +TEST_F(PromotionUtilTest, VerifyPublicKeyWithMismatchedKeys) { + // Arrange + auto promotion = ledger::Promotion::New(); + promotion->credentials = ledger::PromotionCreds::New(); + promotion->public_keys = "[\"orBZ6dkSFLwBtQgI+5qXFb0dzDSm4uf+Km6AhytgUT8=\"]"; + promotion->credentials->public_key = "dfsdfsdf"; + + // Act + bool result = braveledger_promotion::VerifyPublicKey(promotion->Clone()); + + // Assert + EXPECT_EQ(result, false); +} + +TEST_F(PromotionUtilTest, VerifyPublicKeyWithMatchingKeys) { + // Arrange + auto promotion = ledger::Promotion::New(); + promotion->credentials = ledger::PromotionCreds::New(); + promotion->public_keys = "[\"orBZ6dkSFLwBtQgI+5qXFb0dzDSm4uf+Km6AhytgUT8=\"]"; + promotion->credentials->public_key = + "orBZ6dkSFLwBtQgI+5qXFb0dzDSm4uf+Km6AhytgUT8="; + + // Act + bool result = braveledger_promotion::VerifyPublicKey(promotion->Clone()); + + // Assert + EXPECT_EQ(result, true); +} + } // namespace braveledger_promotion diff --git a/vendor/bat-native-ledger/src/bat/ledger/internal/test/mock_ledger_client.cc b/vendor/bat-native-ledger/src/bat/ledger/internal/test/mock_ledger_client.cc index 6c8c485d095c..08f8f24361b1 100644 --- a/vendor/bat-native-ledger/src/bat/ledger/internal/test/mock_ledger_client.cc +++ b/vendor/bat-native-ledger/src/bat/ledger/internal/test/mock_ledger_client.cc @@ -55,13 +55,4 @@ void MockLedgerClient::SavePublisherState( handler->OnPublisherStateSaved(ledger::Result::OK); } -void MockLedgerClient::LoadURL(const std::string& url, - const std::vector& headers, - const std::string& content, - const std::string& contentType, - const ledger::UrlMethod method, - ledger::LoadURLCallback callback) { - callback(true, "{}", {}); -} - } // namespace bat_ledger diff --git a/vendor/bat-native-ledger/src/bat/ledger/internal/test/mock_ledger_client.h b/vendor/bat-native-ledger/src/bat/ledger/internal/test/mock_ledger_client.h index a905b8350eb1..019f22e81992 100644 --- a/vendor/bat-native-ledger/src/bat/ledger/internal/test/mock_ledger_client.h +++ b/vendor/bat-native-ledger/src/bat/ledger/internal/test/mock_ledger_client.h @@ -29,6 +29,14 @@ class MockLedgerClient : public ledger::LedgerClient { void CreateWallet(ledger::LedgerCallbackHandler* handler) override; + MOCK_METHOD6(LoadURL, + void(const std::string&, + const std::vector&, + const std::string&, + const std::string&, + const ledger::UrlMethod, + ledger::LoadURLCallback)); + protected: // ledger::LedgerClient std::string GenerateGUID() const override; @@ -38,12 +46,6 @@ class MockLedgerClient : public ledger::LedgerClient { ledger::LedgerCallbackHandler* handler) override; void SavePublisherState(const std::string& publisher_state, ledger::LedgerCallbackHandler* handler) override; - uint64_t LoadURL(const std::string& url, - const std::vector& headers, - const std::string& content, - const std::string& contentType, - const ledger::UrlMethod method, - ledger::LedgerCallbackHandler* handler) override; std::unique_ptr ledger_; std::string ledger_state_; diff --git a/vendor/bat-native-ledger/src/bat/ledger/internal/uphold/uphold_unittest.cc b/vendor/bat-native-ledger/src/bat/ledger/internal/uphold/uphold_unittest.cc index 798330410420..41a95f33d13f 100644 --- a/vendor/bat-native-ledger/src/bat/ledger/internal/uphold/uphold_unittest.cc +++ b/vendor/bat-native-ledger/src/bat/ledger/internal/uphold/uphold_unittest.cc @@ -39,7 +39,7 @@ class UpholdTest : public testing::Test { }; TEST_F(UpholdTest, FetchBalanceConnectedWallet) { - EXPECT_CALL(*mock_ledger_impl_, LoadURL(_, _, _, _, _, _)).Times(0); + EXPECT_CALL(*mock_ledger_client_, LoadURL(_, _, _, _, _, _)).Times(0); std::map wallets;