src/xwalk/application/common/manifest_handlers/tizen_metadata_handler_unittest.cc

   1 // Copyright (c) 2014 Samsung Electronics Co., Ltd 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 <string>
   6 #include <vector>
   7
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/values.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11 #include "xwalk/application/common/application_manifest_constants.h"
  12 #include "xwalk/application/common/manifest.h"
  13 #include "xwalk/application/common/manifest_handlers/tizen_metadata_handler.h"
  14 #include "xwalk/application/common/manifest_handlers/unittest_util.h"
  15
  16 namespace xwalk {
  17
  18 namespace keys = application_widget_keys;
  19
  20 namespace application {
  21
  22 namespace {
  23
  24 const TizenMetaDataInfo* GetInfo(scoped_refptr<ApplicationData> application) {
  25   const TizenMetaDataInfo* info = static_cast<TizenMetaDataInfo*>(
  26       application->GetManifestData(keys::kTizenMetaDataKey));
  27   return info;
  28 }
  29
  30 scoped_ptr<base::DictionaryValue> CreateMetadata(const char* key,
  31                                                  const char* value) {
  32   scoped_ptr<base::DictionaryValue> metadata(new base::DictionaryValue);
  33   metadata->SetString(keys::kNamespaceKey, keys::kTizenNamespacePrefix);
  34   if (key)
  35     metadata->SetString(keys::kTizenMetaDataNameKey, key);
  36   if (value)
  37     metadata->SetString(keys::kTizenMetaDataValueKey, value);
  38   return metadata.Pass();
  39 }
  40
  41 }  // namespace
  42
  43 class TizenMetadataHandlerTest: public testing::Test {
  44 };
  45
  46 // Verifies Getters and Setters of TizenMetaDataInfo class
  47 TEST_F(TizenMetadataHandlerTest, MetaDataInfoContent) {
  48   TizenMetaDataInfo tizenMetaDataInfo;
  49   EXPECT_FALSE(tizenMetaDataInfo.HasKey("key"));
  50   EXPECT_FALSE(tizenMetaDataInfo.HasKey("primaryKey"));
  51   tizenMetaDataInfo.SetValue("key", "value");
  52   tizenMetaDataInfo.SetValue("primaryKey", "importantValue");
  53   EXPECT_TRUE(tizenMetaDataInfo.HasKey("key"));
  54   EXPECT_TRUE(tizenMetaDataInfo.HasKey("primaryKey"));
  55   EXPECT_FALSE(tizenMetaDataInfo.HasKey("value"));
  56   EXPECT_FALSE(tizenMetaDataInfo.HasKey("importantValue"));
  57   EXPECT_FALSE(tizenMetaDataInfo.HasKey("xyz"));
  58   EXPECT_EQ(tizenMetaDataInfo.GetValue("key"), "value");
  59   EXPECT_EQ(tizenMetaDataInfo.GetValue("primaryKey"), "importantValue");
  60 }
  61
  62 // Verifies parsing manifest doesn't containing any metadata info
  63 TEST_F(TizenMetadataHandlerTest, NoMetaData) {
  64   scoped_ptr<base::DictionaryValue> manifest = CreateDefaultWidgetConfig();
  65   scoped_refptr<ApplicationData> application =
  66       CreateApplication(Manifest::Type::TYPE_WIDGET, *manifest);
  67   EXPECT_NE(nullptr, application.get());
  68   const TizenMetaDataInfo* info = GetInfo(application);
  69   EXPECT_EQ(nullptr, info);
  70 }
  71
  72 // Verifies parsing manifest containing one complete metadata key
  73 TEST_F(TizenMetadataHandlerTest, OneMetaData) {
  74   scoped_ptr<base::DictionaryValue> manifest = CreateDefaultWidgetConfig();
  75   manifest->Set(keys::kTizenMetaDataKey,
  76                 CreateMetadata("someKey", "someValue").release());
  77   scoped_refptr<ApplicationData> application =
  78       CreateApplication(Manifest::Type::TYPE_WIDGET, *manifest);
  79   EXPECT_NE(nullptr, application.get());
  80   const TizenMetaDataInfo* info = GetInfo(application);
  81   EXPECT_NE(nullptr, info);
  82   EXPECT_EQ(1, info->metadata().size());
  83 }
  84
  85 // Verifies parsing manifest containing metadata key without value
  86 TEST_F(TizenMetadataHandlerTest, MetaDataNoValue) {
  87   scoped_ptr<base::DictionaryValue> manifest = CreateDefaultWidgetConfig();
  88   manifest->Set(keys::kTizenMetaDataKey,
  89                 CreateMetadata("someKey", nullptr).release());
  90   scoped_refptr<ApplicationData> application =
  91       CreateApplication(Manifest::Type::TYPE_WIDGET, *manifest);
  92   EXPECT_NE(nullptr, application.get());
  93   const TizenMetaDataInfo* info = GetInfo(application);
  94   EXPECT_NE(nullptr, info);
  95   EXPECT_EQ(1, info->metadata().size());
  96   EXPECT_EQ("someKey", info->metadata().begin()->first);
  97   EXPECT_TRUE(info->metadata().begin()->second.empty());
  98 }
  99
 100 // Verifies parsing manifest containing no key
 101 TEST_F(TizenMetadataHandlerTest, MetaDataNoKey) {
 102   scoped_ptr<base::DictionaryValue> manifest = CreateDefaultWidgetConfig();
 103   manifest->Set(keys::kTizenMetaDataKey,
 104                 CreateMetadata(nullptr, "someValue").release());
 105   scoped_refptr<ApplicationData> application =
 106       CreateApplication(Manifest::Type::TYPE_WIDGET, *manifest);
 107   EXPECT_EQ(nullptr, application.get());
 108 }
 109
 110 // Verifies parsing manifest containing empty key
 111 TEST_F(TizenMetadataHandlerTest, MetaDataEmptyKey) {
 112   scoped_ptr<base::DictionaryValue> manifest = CreateDefaultWidgetConfig();
 113   manifest->Set(keys::kTizenMetaDataKey,
 114                 CreateMetadata("", "someValue").release());
 115   scoped_refptr<ApplicationData> application =
 116       CreateApplication(Manifest::Type::TYPE_WIDGET, *manifest);
 117   EXPECT_EQ(nullptr, application.get());
 118 }
 119
 120 // Verifies parsing manifest containing no key and no value
 121 TEST_F(TizenMetadataHandlerTest, MetaDataNoKeyAndNoValue) {
 122   scoped_ptr<base::DictionaryValue> manifest = CreateDefaultWidgetConfig();
 123   manifest->Set(keys::kTizenMetaDataKey,
 124                 CreateMetadata(nullptr, nullptr).release());
 125   scoped_refptr<ApplicationData> application =
 126       CreateApplication(Manifest::Type::TYPE_WIDGET, *manifest);
 127   EXPECT_EQ(nullptr, application.get());
 128 }
 129
 130 }  // namespace application
 131 }  // namespace xwalk