src/chrome/browser/extensions/convert_web_app_unittest.cc

   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 #include "chrome/browser/extensions/convert_web_app.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/file_util.h"
  11 #include "base/files/file_path.h"
  12 #include "base/files/scoped_temp_dir.h"
  13 #include "base/path_service.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "base/time/time.h"
  17 #include "base/version.h"
  18 #include "chrome/common/chrome_paths.h"
  19 #include "chrome/common/extensions/extension_icon_set.h"
  20 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
  21 #include "chrome/common/extensions/manifest_handlers/icons_handler.h"
  22 #include "chrome/common/web_application_info.h"
  23 #include "extensions/common/extension.h"
  24 #include "extensions/common/extension_resource.h"
  25 #include "extensions/common/permissions/permission_set.h"
  26 #include "extensions/common/url_pattern.h"
  27 #include "testing/gtest/include/gtest/gtest.h"
  28 #include "ui/gfx/codec/png_codec.h"
  29 #include "url/gurl.h"
  30
  31 namespace extensions {
  32
  33 namespace {
  34
  35 // Returns an icon info corresponding to a canned icon.
  36 WebApplicationInfo::IconInfo GetIconInfo(const GURL& url, int size) {
  37   WebApplicationInfo::IconInfo result;
  38
  39   base::FilePath icon_file;
  40   if (!PathService::Get(chrome::DIR_TEST_DATA, &icon_file)) {
  41     ADD_FAILURE() << "Could not get test data directory.";
  42     return result;
  43   }
  44
  45   icon_file = icon_file.AppendASCII("extensions")
  46                        .AppendASCII("convert_web_app")
  47                        .AppendASCII(base::StringPrintf("%i.png", size));
  48
  49   result.url = url;
  50   result.width = size;
  51   result.height = size;
  52
  53   std::string icon_data;
  54   if (!base::ReadFileToString(icon_file, &icon_data)) {
  55     ADD_FAILURE() << "Could not read test icon.";
  56     return result;
  57   }
  58
  59   if (!gfx::PNGCodec::Decode(
  60         reinterpret_cast<const unsigned char*>(icon_data.c_str()),
  61         icon_data.size(), &result.data)) {
  62     ADD_FAILURE() << "Could not decode test icon.";
  63     return result;
  64   }
  65
  66   return result;
  67 }
  68
  69 base::Time GetTestTime(int year, int month, int day, int hour, int minute,
  70                        int second, int millisecond) {
  71   base::Time::Exploded exploded = {0};
  72   exploded.year = year;
  73   exploded.month = month;
  74   exploded.day_of_month = day;
  75   exploded.hour = hour;
  76   exploded.minute = minute;
  77   exploded.second = second;
  78   exploded.millisecond = millisecond;
  79   return base::Time::FromUTCExploded(exploded);
  80 }
  81
  82 }  // namespace
  83
  84 TEST(ExtensionFromWebApp, GenerateVersion) {
  85   EXPECT_EQ("2010.1.1.0",
  86             ConvertTimeToExtensionVersion(
  87                 GetTestTime(2010, 1, 1, 0, 0, 0, 0)));
  88   EXPECT_EQ("2010.12.31.22111",
  89             ConvertTimeToExtensionVersion(
  90                 GetTestTime(2010, 12, 31, 8, 5, 50, 500)));
  91   EXPECT_EQ("2010.10.1.65535",
  92             ConvertTimeToExtensionVersion(
  93                 GetTestTime(2010, 10, 1, 23, 59, 59, 999)));
  94 }
  95
  96 TEST(ExtensionFromWebApp, Basic) {
  97   base::ScopedTempDir extensions_dir;
  98   ASSERT_TRUE(extensions_dir.CreateUniqueTempDir());
  99
 100   WebApplicationInfo web_app;
 101   web_app.title = base::ASCIIToUTF16("Gearpad");
 102   web_app.description =
 103       base::ASCIIToUTF16("The best text editor in the universe!");
 104   web_app.app_url = GURL("http://aaronboodman.com/gearpad/");
 105
 106   const int sizes[] = {16, 48, 128};
 107   for (size_t i = 0; i < arraysize(sizes); ++i) {
 108     GURL icon_url(
 109         web_app.app_url.Resolve(base::StringPrintf("%i.png", sizes[i])));
 110     web_app.icons.push_back(GetIconInfo(icon_url, sizes[i]));
 111   }
 112
 113   scoped_refptr<Extension> extension = ConvertWebAppToExtension(
 114       web_app, GetTestTime(1978, 12, 11, 0, 0, 0, 0),
 115       extensions_dir.path());
 116   ASSERT_TRUE(extension.get());
 117
 118   base::ScopedTempDir extension_dir;
 119   EXPECT_TRUE(extension_dir.Set(extension->path()));
 120
 121   EXPECT_TRUE(extension->is_app());
 122   EXPECT_TRUE(extension->is_hosted_app());
 123   EXPECT_FALSE(extension->is_legacy_packaged_app());
 124
 125   EXPECT_EQ("zVvdNZy3Mp7CFU8JVSyXNlDuHdVLbP7fDO3TGVzj/0w=",
 126             extension->public_key());
 127   EXPECT_EQ("oplhagaaipaimkjlbekcdjkffijdockj", extension->id());
 128   EXPECT_EQ("1978.12.11.0", extension->version()->GetString());
 129   EXPECT_EQ(base::UTF16ToUTF8(web_app.title), extension->name());
 130   EXPECT_EQ(base::UTF16ToUTF8(web_app.description), extension->description());
 131   EXPECT_EQ(web_app.app_url, AppLaunchInfo::GetFullLaunchURL(extension.get()));
 132   EXPECT_EQ(0u, extension->GetActivePermissions()->apis().size());
 133   ASSERT_EQ(0u, extension->web_extent().patterns().size());
 134
 135   EXPECT_EQ(web_app.icons.size(),
 136             IconsInfo::GetIcons(extension.get()).map().size());
 137   for (size_t i = 0; i < web_app.icons.size(); ++i) {
 138     EXPECT_EQ(base::StringPrintf("icons/%i.png", web_app.icons[i].width),
 139               IconsInfo::GetIcons(extension.get()).Get(
 140                   web_app.icons[i].width, ExtensionIconSet::MATCH_EXACTLY));
 141     ExtensionResource resource =
 142         IconsInfo::GetIconResource(extension.get(),
 143                                    web_app.icons[i].width,
 144                                    ExtensionIconSet::MATCH_EXACTLY);
 145     ASSERT_TRUE(!resource.empty());
 146     EXPECT_TRUE(base::PathExists(resource.GetFilePath()));
 147   }
 148 }
 149
 150 TEST(ExtensionFromWebApp, Minimal) {
 151   base::ScopedTempDir extensions_dir;
 152   ASSERT_TRUE(extensions_dir.CreateUniqueTempDir());
 153
 154   WebApplicationInfo web_app;
 155   web_app.title = base::ASCIIToUTF16("Gearpad");
 156   web_app.app_url = GURL("http://aaronboodman.com/gearpad/");
 157
 158   scoped_refptr<Extension> extension = ConvertWebAppToExtension(
 159       web_app, GetTestTime(1978, 12, 11, 0, 0, 0, 0),
 160       extensions_dir.path());
 161   ASSERT_TRUE(extension.get());
 162
 163   base::ScopedTempDir extension_dir;
 164   EXPECT_TRUE(extension_dir.Set(extension->path()));
 165
 166   EXPECT_TRUE(extension->is_app());
 167   EXPECT_TRUE(extension->is_hosted_app());
 168   EXPECT_FALSE(extension->is_legacy_packaged_app());
 169
 170   EXPECT_EQ("zVvdNZy3Mp7CFU8JVSyXNlDuHdVLbP7fDO3TGVzj/0w=",
 171             extension->public_key());
 172   EXPECT_EQ("oplhagaaipaimkjlbekcdjkffijdockj", extension->id());
 173   EXPECT_EQ("1978.12.11.0", extension->version()->GetString());
 174   EXPECT_EQ(base::UTF16ToUTF8(web_app.title), extension->name());
 175   EXPECT_EQ("", extension->description());
 176   EXPECT_EQ(web_app.app_url, AppLaunchInfo::GetFullLaunchURL(extension.get()));
 177   EXPECT_EQ(0u, IconsInfo::GetIcons(extension.get()).map().size());
 178   EXPECT_EQ(0u, extension->GetActivePermissions()->apis().size());
 179   ASSERT_EQ(0u, extension->web_extent().patterns().size());
 180 }
 181
 182 }  // namespace extensions