Expand the functionality of the BudgetDatabase.

chrome/browser/budget_service/budget_database_unittest.cc

 // Copyright 2016 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 "chrome/browser/budget_service/budget_database.h"
 
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/budget_service/budget.pb.h"
 #include "chrome/test/base/testing_profile.h"
@@ skipping 24 matching lines @@
     run_loop_closure.Run();
   }
 
   // Set up basic default values.
   bool SetBudgetWithDefaultValues() {
     budget_service::Budget budget;
     budget.set_debt(kDefaultDebt);
 
     // Create two chunks and give them default values.
     budget_service::BudgetChunk* budget_chunk = budget.add_budget();
-    budget_chunk->set_budget_amount(kDefaultBudget1);
-    budget_chunk->set_expiration_timestamp(kDefaultExpiration);
+    budget_chunk->set_amount(kDefaultBudget1);
+    budget_chunk->set_expiration(kDefaultExpiration);
     budget_chunk = budget.add_budget();
-    budget_chunk->set_budget_amount(kDefaultBudget2);
-    budget_chunk->set_expiration_timestamp(kDefaultExpiration + 1);
+    budget_chunk->set_amount(kDefaultBudget2);
+    budget_chunk->set_expiration(kDefaultExpiration + 1);
 
     base::RunLoop run_loop;
     db_.SetValue(GURL(kTestOrigin), budget,
                  base::Bind(&BudgetDatabaseTest::SetBudgetComplete,
                             base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
 
     return success_;
   }
 
   void GetBudgetComplete(base::Closure run_loop_closure,
                          bool success,
                          std::unique_ptr<budget_service::Budget> budget) {
     budget_ = std::move(budget);
     success_ = success;
     run_loop_closure.Run();
   }
 
   // Excercise the very basic get method.
   std::unique_ptr<budget_service::Budget> GetBudget() {
     base::RunLoop run_loop;
     db_.GetValue(GURL(kTestOrigin),
                  base::Bind(&BudgetDatabaseTest::GetBudgetComplete,
                             base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
     return std::move(budget_);
   }
 
+  void GetBudgetDetailsComplete(
+      base::Closure run_loop_closure,
+      bool success,
+      double debt,
+      const BudgetDatabase::BudgetExpectation& expectation) {
+    success_ = success;
+    debt_ = debt;
+    expectation_ = expectation;
+    run_loop_closure.Run();
+  }
+
+  void GetBudgetDetails() {
+    base::RunLoop run_loop;
+    db_.GetBudgetDetails(
+        GURL(kTestOrigin),
+        base::Bind(&BudgetDatabaseTest::GetBudgetDetailsComplete,
+                   base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+    return;

[Peter Beverloo, 2016/07/26 17:26:21]

nit: drop (control flow ends after this anyway)

[harkness, 2016/07/27 10:59:03]

Done.

+  }
+
   Profile* profile() { return &profile_; }
+  const BudgetDatabase::BudgetExpectation& expectation() {
+    return expectation_;
+  }
 
  protected:
   bool success_;
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<budget_service::Budget> budget_;
   TestingProfile profile_;
   BudgetDatabase db_;
+  double debt_;

[Peter Beverloo, 2016/07/26 17:26:21]

init (double debt_ = 0;)

[harkness, 2016/07/27 10:59:03]

Done.

+  BudgetDatabase::BudgetExpectation expectation_;
 };
 
 TEST_F(BudgetDatabaseTest, ReadAndWriteTest) {
   ASSERT_TRUE(SetBudgetWithDefaultValues());
   std::unique_ptr<budget_service::Budget> b = GetBudget();
 
   ASSERT_TRUE(success_);
   EXPECT_EQ(kDefaultDebt, b->debt());
-  EXPECT_EQ(kDefaultBudget1, b->budget(0).budget_amount());
-  EXPECT_EQ(kDefaultBudget2, b->budget(1).budget_amount());
-  EXPECT_EQ(kDefaultExpiration, b->budget(0).expiration_timestamp());
+  EXPECT_EQ(kDefaultBudget1, b->budget(0).amount());
+  EXPECT_EQ(kDefaultBudget2, b->budget(1).amount());
+  EXPECT_EQ(kDefaultExpiration, b->budget(0).expiration());
+}
+
+TEST_F(BudgetDatabaseTest, BudgetDetailsTest) {
+  ASSERT_TRUE(SetBudgetWithDefaultValues());
+  GetBudgetDetails();
+
+  // Get the expectation and validate it.
+  const BudgetDatabase::BudgetExpectation exp = expectation();

[Peter Beverloo, 2016/07/26 17:26:21]

nit 2: perfectly fine to use const auto& here. Try to avoid shorter names such
as "exp" where possible.

[Peter Beverloo, 2016/07/26 17:26:21]

nit 1: expectation() returns a reference, so no need to make a copy.

[harkness, 2016/07/27 10:59:03]

Done.

[harkness, 2016/07/27 10:59:03]

Done.

+  ASSERT_TRUE(success_);
+
+  // Make sure that the correct data is returned.
+  BudgetDatabase::BudgetExpectation::const_iterator iter = exp.begin();

[Peter Beverloo, 2016/07/26 17:26:21]

nit: const auto& iter = ...?

[harkness, 2016/07/27 10:59:03]

I did some reading on const_iterator and auto, and it doesn't seem like there's
a good way to do this. Let's talk about it in person.

[Peter Beverloo, 2016/07/27 11:21:40]

Ugh ok. Could still use `auto` (const-ness doesn't really matter here), or leave
as-is. Up to you.

+  ASSERT_EQ(exp.size(), (const unsigned long)3);

[Peter Beverloo, 2016/07/26 17:26:21]

nit 1: This ASSERT should be under line 133, it's unrelated to line 136.

[Peter Beverloo, 2016/07/26 17:26:21]

nit 3: We disallow c-style casts in Chromium. In this case you can use the "U"
suffix:  3U

[Peter Beverloo, 2016/07/26 17:26:21]

nit 2: Canonical use of the {ASSERT,EXPECT}_EQ macros is (expected, actual),
which affects the error messages GTest prints. Dito further down.

[harkness, 2016/07/27 10:59:03]

Done.

[harkness, 2016/07/27 10:59:03]

Done.

[harkness, 2016/07/27 10:59:03]

Done.

+
+  // First value should be [total_budget, now]
+  EXPECT_EQ(iter->first, kDefaultBudget1 + kDefaultBudget2);
+  // TODO(harkness): This will be "now" in the final version. For now, it's
+  // just 0.0.
+  EXPECT_EQ(iter->second, 0.0);

[Peter Beverloo, 2016/07/26 17:26:21]

nit: s/0.0/0/ (dito on line 152)

[harkness, 2016/07/27 10:59:03]

Done.

+
+  // The next value should be the budget after the first chunk expires.
+  iter++;
+  EXPECT_EQ(iter->first, kDefaultBudget2);
+  EXPECT_EQ(iter->second, kDefaultExpiration);
+
+  // The final value gives the budget of 0.0 after the second chunk expires.
+  iter++;
+  EXPECT_EQ(iter->first, 0.0);
+  EXPECT_EQ(iter->second, kDefaultExpiration + 1);
 }
 
 }  // namespace