extensions/common/manifest_test.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef EXTENSIONS_COMMON_MANIFEST_TEST_H_
   6 #define EXTENSIONS_COMMON_MANIFEST_TEST_H_
   7
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/values.h"
  11 #include "extensions/common/extension.h"
  12 #include "extensions/common/manifest.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace base {
  16 class FilePath;
  17 }
  18
  19 namespace extensions {
  20
  21 // Base class for tests that parse a manifest file.
  22 class ManifestTest : public testing::Test {
  23  public:
  24   ManifestTest();
  25   ~ManifestTest() override;
  26
  27  protected:
  28   // Helper class that simplifies creating methods that take either a filename
  29   // to a manifest or the manifest itself.
  30   class ManifestData {
  31    public:
  32     explicit ManifestData(const char* name);
  33     ManifestData(base::DictionaryValue* manifest, const char* name);
  34     explicit ManifestData(scoped_ptr<base::DictionaryValue> manifest);
  35     // C++98 requires the copy constructor for a type to be visible if you
  36     // take a const-ref of a temporary for that type.  Since Manifest
  37     // contains a scoped_ptr, its implicit copy constructor is declared
  38     // Manifest(Manifest&) according to spec 12.8.5.  This breaks the first
  39     // requirement and thus you cannot use it with LoadAndExpectError() or
  40     // LoadAndExpectSuccess() easily.
  41     //
  42     // To get around this spec pedantry, we declare the copy constructor
  43     // explicitly.  It will never get invoked.
  44     ManifestData(const ManifestData& m);
  45
  46     ~ManifestData();
  47
  48     const std::string& name() const { return name_; };
  49
  50     base::DictionaryValue* GetManifest(base::FilePath manifest_path,
  51                                        std::string* error) const;
  52
  53    private:
  54     const std::string name_;
  55     mutable base::DictionaryValue* manifest_;
  56     mutable scoped_ptr<base::DictionaryValue> manifest_holder_;
  57   };
  58
  59   // Returns the path in which to find test manifest data files, for example
  60   // extensions/test/data/manifest_tests.
  61   virtual base::FilePath GetTestDataDir();
  62
  63   scoped_ptr<base::DictionaryValue> LoadManifest(
  64       char const* manifest_name,
  65       std::string* error);
  66
  67   scoped_refptr<extensions::Extension> LoadExtension(
  68       const ManifestData& manifest,
  69       std::string* error,
  70       extensions::Manifest::Location location =
  71           extensions::Manifest::INTERNAL,
  72       int flags = extensions::Extension::NO_FLAGS);
  73
  74   scoped_refptr<extensions::Extension> LoadAndExpectSuccess(
  75       const ManifestData& manifest,
  76       extensions::Manifest::Location location =
  77           extensions::Manifest::INTERNAL,
  78       int flags = extensions::Extension::NO_FLAGS);
  79
  80   scoped_refptr<extensions::Extension> LoadAndExpectSuccess(
  81       char const* manifest_name,
  82       extensions::Manifest::Location location =
  83           extensions::Manifest::INTERNAL,
  84       int flags = extensions::Extension::NO_FLAGS);
  85
  86   scoped_refptr<extensions::Extension> LoadAndExpectWarning(
  87       const ManifestData& manifest,
  88       const std::string& expected_error,
  89       extensions::Manifest::Location location =
  90           extensions::Manifest::INTERNAL,
  91       int flags = extensions::Extension::NO_FLAGS);
  92
  93   scoped_refptr<extensions::Extension> LoadAndExpectWarning(
  94       char const* manifest_name,
  95       const std::string& expected_error,
  96       extensions::Manifest::Location location =
  97           extensions::Manifest::INTERNAL,
  98       int flags = extensions::Extension::NO_FLAGS);
  99
 100   void VerifyExpectedError(extensions::Extension* extension,
 101                            const std::string& name,
 102                            const std::string& error,
 103                            const std::string& expected_error);
 104
 105   void LoadAndExpectError(char const* manifest_name,
 106                           const std::string& expected_error,
 107                           extensions::Manifest::Location location =
 108                               extensions::Manifest::INTERNAL,
 109                           int flags = extensions::Extension::NO_FLAGS);
 110
 111   void LoadAndExpectError(const ManifestData& manifest,
 112                           const std::string& expected_error,
 113                           extensions::Manifest::Location location =
 114                               extensions::Manifest::INTERNAL,
 115                           int flags = extensions::Extension::NO_FLAGS);
 116
 117   void AddPattern(extensions::URLPatternSet* extent,
 118                   const std::string& pattern);
 119
 120   // used to differentiate between calls to LoadAndExpectError,
 121   // LoadAndExpectWarning and LoadAndExpectSuccess via function RunTestcases.
 122   enum ExpectType {
 123     EXPECT_TYPE_ERROR,
 124     EXPECT_TYPE_WARNING,
 125     EXPECT_TYPE_SUCCESS
 126   };
 127
 128   struct Testcase {
 129     std::string manifest_filename_;
 130     std::string expected_error_; // only used for ExpectedError tests
 131     extensions::Manifest::Location location_;
 132     int flags_;
 133
 134     Testcase(std::string manifest_filename, std::string expected_error,
 135         extensions::Manifest::Location location, int flags);
 136
 137     Testcase(std::string manifest_filename, std::string expected_error);
 138
 139     explicit Testcase(std::string manifest_filename);
 140
 141     Testcase(std::string manifest_filename,
 142              extensions::Manifest::Location location,
 143              int flags);
 144   };
 145
 146   void RunTestcases(const Testcase* testcases,
 147                     size_t num_testcases,
 148                     ExpectType type);
 149
 150   void RunTestcase(const Testcase& testcase, ExpectType type);
 151
 152   bool enable_apps_;
 153
 154  private:
 155   DISALLOW_COPY_AND_ASSIGN(ManifestTest);
 156 };
 157
 158 }  // namespace extensions
 159
 160 #endif  // EXTENSIONS_COMMON_MANIFEST_TEST_H_