From 949f1abfc9d14b44d33c9610b9a0517aa78ae4bc Mon Sep 17 00:00:00 2001 From: rbock Date: Sun, 19 Jun 2016 10:41:31 +0200 Subject: [PATCH] Added static_assert tests for update set/dynamic_set --- include/sqlpp11/update_list.h | 5 +- test_static_asserts/CMakeLists.txt | 1 + test_static_asserts/update_list.cpp | 140 ++++++++++++++++++++++++++++ 3 files changed, 144 insertions(+), 2 deletions(-) create mode 100644 test_static_asserts/update_list.cpp diff --git a/include/sqlpp11/update_list.h b/include/sqlpp11/update_list.h index d447c8a2..c7dc360c 100644 --- a/include/sqlpp11/update_list.h +++ b/include/sqlpp11/update_list.h @@ -268,9 +268,10 @@ namespace sqlpp template auto dynamic_set(Assignments... assignments) const - -> _new_statement_t, update_list_t<_database_t, Assignments...>> + -> _new_statement_t, + update_list_t<_database_t, Assignments...>> { - using Check = check_update_dynamic_set_t; + using Check = check_update_dynamic_set_t<_database_t, Assignments...>; Check{}._(); return _set_impl<_database_t>(Check{}, assignments...); diff --git a/test_static_asserts/CMakeLists.txt b/test_static_asserts/CMakeLists.txt index d1b8c542..f9b76f35 100644 --- a/test_static_asserts/CMakeLists.txt +++ b/test_static_asserts/CMakeLists.txt @@ -33,6 +33,7 @@ test_compile(case) test_compile(from) test_compile(join) test_compile(where) +test_compile(update_list) test_compile(having) test_compile(insert) test_compile(in) diff --git a/test_static_asserts/update_list.cpp b/test_static_asserts/update_list.cpp new file mode 100644 index 00000000..06838013 --- /dev/null +++ b/test_static_asserts/update_list.cpp @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2016-2016, Roland Bock + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include "MockDb.h" +#include "Sample.h" +#include + +namespace +{ + constexpr auto t = test::TabBar{}; + constexpr auto f = test::TabFoo{}; + + template + void print_type_on_error(std::true_type) + { + } + + template + void print_type_on_error(std::false_type) + { + T::_print_me_; + } + + template + void update_set_static_check(const Expressions&... expressions) + { + using CheckResult = sqlpp::check_update_static_set_t; + using ExpectedCheckResult = std::is_same; + print_type_on_error(ExpectedCheckResult{}); + static_assert(ExpectedCheckResult::value, "Unexpected check result"); + + using ReturnType = decltype(update(t).set(expressions...)); + using ExpectedReturnType = + sqlpp::logic::all_t::value>; + print_type_on_error(ExpectedReturnType{}); + static_assert(ExpectedReturnType::value, "Unexpected return type"); + } + + template + void update_set_dynamic_check(const Expressions&... expressions) + { + static auto db = MockDb{}; + using CheckResult = sqlpp::check_update_dynamic_set_t; + using ExpectedCheckResult = std::is_same; + print_type_on_error(ExpectedCheckResult{}); + static_assert(ExpectedCheckResult::value, "Unexpected check result"); + + using ReturnType = decltype(dynamic_update(db, t).dynamic_set(expressions...)); + using ExpectedReturnType = + sqlpp::logic::all_t::value>; + print_type_on_error(ExpectedReturnType{}); + static_assert(ExpectedReturnType::value, "Unexpected return type"); + } + + void static_update_set() + { + // OK + update_set_static_check(t.gamma = true); + update_set_static_check(t.gamma = true, t.beta = ""); + + // Try to update nothing + update_set_static_check(); + + // Try condition as assignment + update_set_static_check(t.gamma == true); + + // Try duplicate columns + update_set_static_check(t.gamma = true, t.gamma = false); + update_set_static_check(t.gamma = true, t.beta = "", t.gamma = false); + + // Try to update prohibited columns + update_set_static_check(t.alpha = 42); + + // Try to update multiple tables at once + update_set_static_check(t.gamma = true, f.omega = 7); + } + + void dynamic_update_set() + { + // OK + update_set_dynamic_check(t.gamma = true); + update_set_dynamic_check(t.gamma = true, t.beta = ""); + + // Try to update nothing + update_set_dynamic_check(); + + // Try condition as assignment + update_set_dynamic_check(t.gamma == true); + + // Try duplicate columns + update_set_dynamic_check(t.gamma = true, t.gamma = false); + update_set_dynamic_check(t.gamma = true, t.beta = "", t.gamma = false); + + // Try to update prohibited columns + update_set_dynamic_check(t.alpha = 42); + + // Try to update multiple tables at once + update_set_dynamic_check(t.gamma = true, f.omega = 7); + + // Try dynamic_set on a non-dynamic update + using CheckResult = sqlpp::check_update_dynamic_set_t; + using ExpectedCheckResult = std::is_same; + print_type_on_error(ExpectedCheckResult{}); + static_assert(ExpectedCheckResult::value, "Unexpected check result"); + + using ReturnType = decltype(update(t).dynamic_set()); + using ExpectedReturnType = std::is_same; + print_type_on_error(ExpectedReturnType{}); + static_assert(ExpectedReturnType::value, "Unexpected return type"); + } +} + +int main(int, char* []) +{ + static_update_set(); + dynamic_update_set(); +}