src/vist/query-builder/tests/query-builder.cpp

   1 /*
   2  *  Copyright (c) 2017-present Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License
  15  */
  16
  17 #include <vist/query-builder.hpp>
  18
  19 #include <gtest/gtest.h>
  20
  21 using namespace vist::tsqb;
  22
  23 struct Admin {
  24         int id;
  25         std::string pkg;
  26         int uid;
  27         std::string key;
  28         int removable;
  29
  30         inline static Column Id = { "id", &Admin::id };
  31         inline static Column Pkg = { "pkg", &Admin::pkg };
  32         inline static Column Uid = { "uid", &Admin::uid };
  33         inline static Column Key = { "key", &Admin::key };
  34         inline static Column Removable = { "removable", &Admin::removable };
  35 };
  36
  37 static Table AdminTable { "admin", Admin::Id, Admin::Pkg,
  38                                                                    Admin::Uid, Admin::Key, Admin::Removable };
  39
  40 struct ManagedPolicy {
  41         int id;
  42         int aid;
  43         int pid;
  44         int value;
  45
  46         inline static Column Id = { "id", &ManagedPolicy::id };
  47         inline static Column Aid = { "aid", &ManagedPolicy::aid };
  48         inline static Column Pid = { "pid", &ManagedPolicy::pid };
  49         inline static Column Value = { "value", &ManagedPolicy::value };
  50 };
  51
  52 static Table ManagedPolicyTable { "managed_policy", ManagedPolicy::Id,
  53                                                                                                           ManagedPolicy::Aid,
  54                                                                                                           ManagedPolicy::Pid,
  55                                                                                                           ManagedPolicy::Value };
  56
  57 struct PolicyDefinition {
  58         int id;
  59         int scope;
  60         std::string name;
  61         int ivalue;
  62
  63         inline static Column Id = { "id", &PolicyDefinition::id };
  64         inline static Column Scope = { "scope", &PolicyDefinition::scope };
  65         inline static Column Name = { "name", &PolicyDefinition::name };
  66         inline static Column Ivalue = { "ivalue", &PolicyDefinition::ivalue };
  67 };
  68
  69 static Table PolicyDefinition { "policy_definition", PolicyDefinition::Id,
  70                                                                                                          PolicyDefinition::Scope,
  71                                                                                                          PolicyDefinition::Name,
  72                                                                                                          PolicyDefinition::Ivalue };
  73
  74 Table admin { "admin", Column("id", &Admin::id),
  75                                            Column("pkg", &Admin::pkg),
  76                                            Column("uid", &Admin::uid),
  77                                            Column("key", &Admin::key),
  78                                            Column("removable", &Admin::removable) };
  79
  80 Table managedPolicy { "managed_policy", Column("id", &ManagedPolicy::id),
  81                                                                                 Column("aid", &ManagedPolicy::aid),
  82                                                                                 Column("pid", &ManagedPolicy::pid),
  83                                                                                 Column("value", &ManagedPolicy::value) };
  84
  85 Table policyDefinition { "policy_definition", Column("id", &PolicyDefinition::id),
  86                                                                                           Column("scope", &PolicyDefinition::scope),
  87                                                                                           Column("name", &PolicyDefinition::name),
  88                                                                                           Column("ivalue", &PolicyDefinition::ivalue) };
  89
  90 Database db { "dpm", admin, managedPolicy, policyDefinition };
  91
  92 TEST(QueryBuilderTsqbTests, SELECT)
  93 {
  94         std::string select1 = AdminTable.select(Admin::Id, Admin::Pkg, Admin::Uid, Admin::Key);
  95         std::string select2 = AdminTable.select(Admin::Id, Admin::Uid, Admin::Key);
  96
  97         EXPECT_EQ(select1, "SELECT id, pkg, uid, key FROM admin");
  98         EXPECT_EQ(select2, "SELECT id, uid, key FROM admin");
  99 }
 100
 101 TEST(QueryBuilderTsqbTests, SELECT_ALL)
 102 {
 103         std::string select = AdminTable.selectAll();
 104
 105         EXPECT_EQ(select, "SELECT * FROM admin");
 106 }
 107
 108 TEST(QueryBuilderTsqbTests, SELECT_WHERE)
 109 {
 110         std::string select1 = AdminTable.select(Admin::Uid, Admin::Key)
 111                                                                         .where(Admin::Id > 3);
 112         std::string select2 = admin.selectAll().where(Admin::Uid > 3);
 113         std::string select3 = admin.selectAll().where(Admin::Uid > 3 &&
 114                                                                                                   Admin::Pkg == "dpm");
 115         std::string select4 = admin.selectAll().where(Admin::Uid > 3 ||
 116                                                                                                   Admin::Pkg == "dpm");
 117
 118         EXPECT_EQ(select1, "SELECT uid, key FROM admin WHERE id > ?");
 119         EXPECT_EQ(select2, "SELECT * FROM admin WHERE uid > ?");
 120         EXPECT_EQ(select3, "SELECT * FROM admin WHERE uid > ? AND pkg = ?");
 121         EXPECT_EQ(select4, "SELECT * FROM admin WHERE uid > ? OR pkg = ?");
 122 }
 123
 124 TEST(QueryBuilderTsqbTests, UPDATE)
 125 {
 126         int uid = 0, id = 1;
 127         std::string update1 = admin.update(Admin::Id, Admin::Pkg, Admin::Uid, Admin::Key);
 128         std::string update2 = admin.update(Admin::Key).where((Admin::Uid == uid) &&
 129                                                                                                                  (Admin::Id == id));
 130         std::string update3 = admin.update(Admin::Key, Admin::Pkg)
 131                                                            .where((Admin::Uid == 0) && (Admin::Id == 1));
 132
 133         EXPECT_EQ(update1, "UPDATE admin SET id = ?, pkg = ?, uid = ?, key = ?");
 134         EXPECT_EQ(update2, "UPDATE admin SET key = ? WHERE uid = ? AND id = ?");
 135         EXPECT_EQ(update3, "UPDATE admin SET key = ?, pkg = ? WHERE uid = ? AND id = ?");
 136 }
 137
 138 TEST(QueryBuilderTsqbTests, DELETE)
 139 {
 140         std::string delete1 = admin.remove();
 141         std::string delete2 = admin.remove().where((Admin::Pkg == "dpm") &&
 142                                                                                            (Admin::Uid == 3));
 143
 144         EXPECT_EQ(delete1, "DELETE FROM admin");
 145         EXPECT_EQ(delete2, "DELETE FROM admin WHERE pkg = ? AND uid = ?");
 146 }
 147
 148 TEST(QueryBuilderTsqbTests, INSERT)
 149 {
 150         std::string insert1 = AdminTable.insert(Admin::Id, Admin::Pkg, Admin::Uid, Admin::Key);
 151         std::string insert2 = AdminTable.insert(Admin::Id, Admin::Pkg, Admin::Key);
 152
 153         EXPECT_EQ(insert1, "INSERT INTO admin (id, pkg, uid, key) VALUES (?, ?, ?, ?)");
 154         EXPECT_EQ(insert2, "INSERT INTO admin (id, pkg, key) VALUES (?, ?, ?)");
 155 }
 156
 157 TEST(QueryBuilderTsqbTests, TYPE_SAFE)
 158 {
 159 /*
 160  * Below cause complie error since expression types are dismatch.
 161
 162         std::string type_unsafe1 = admin.selectAll().where(Admin::Uid > "dpm");
 163         std::string type_unsafe2 = admin.selectAll().where(Admin::Uid == "dpm");
 164         std::string type_unsafe3 = admin.selectAll().where(Admin::Pkg == 3);
 165         int pkg = 3;
 166         std::string type_unsafe4 = admin.selectAll().where(Admin::Pkg) < pkg);
 167         std::string type_unsafe5 = admin.remove().where(Admin::Pkg) == "dpm" &&
 168                                                                                                         Admin::Uid) == "dpm");
 169 */
 170 }
 171
 172 TEST(QueryBuilderTsqbTests, MULTI_SELECT)
 173 {
 174         std::string multiSelect1 = db.select(Admin::Uid, Admin::Key,
 175                                                                                  ManagedPolicy::Id, ManagedPolicy::Value);
 176         std::string multiSelect2 = db.select(Admin::Uid, Admin::Key,
 177                                                                                  ManagedPolicy::Id, ManagedPolicy::Value)
 178                                                                  .where((Admin::Uid > 0) && (ManagedPolicy::Id == 3));
 179
 180         EXPECT_EQ(multiSelect1, "SELECT admin.uid, admin.key, managed_policy.id, "
 181                                                         "managed_policy.value FROM admin, managed_policy");
 182         EXPECT_EQ(multiSelect2, "SELECT admin.uid, admin.key, managed_policy.id, "
 183                                                         "managed_policy.value FROM admin, managed_policy "
 184                                                         "WHERE admin.uid > ? AND managed_policy.id = ?");
 185 }
 186
 187 /*
 188 TEST(QueryBuilderTsqbTests, JOIN)
 189 {
 190         std::string join1 = db.select(Admin::Uid, Admin::Key)
 191                                                   .join<PolicyDefinition>(condition::Join::LEFT_OUTER);
 192         std::string join2 = db.select(Admin::Uid, Admin::Key)
 193                                                   .join<ManagedPolicy>(condition::Join::CROSS);
 194         std::string join3 = db.select(ManagedPolicy::Value)
 195                                                   .join<PolicyDefinition>()
 196                                                   .on(ManagedPolicy::Pid) == PolicyDefinition::Id))
 197                                                   .join<Admin>()
 198                                                   .on(ManagedPolicy::Aid) == Admin::Id))
 199                                                   .where(ManagedPolicy::Pid) == 99);
 200
 201         EXPECT_EQ(join1, "SELECT admin.uid, admin.key FROM admin "
 202                                          "LEFT OUTER JOIN policy_definition");
 203         EXPECT_EQ(join2, "SELECT admin.uid, admin.key FROM admin "
 204                                          "CROSS JOIN managed_policy");
 205         EXPECT_EQ(join3, "SELECT managed_policy.value FROM managed_policy "
 206                                          "INNER JOIN policy_definition "
 207                                          "ON managed_policy.pid = policy_definition.id "
 208                                          "INNER JOIN admin ON managed_policy.aid = admin.id "
 209                                          "WHERE managed_policy.pid = ?");
 210 }
 211 */