libdballe  7.6
db/tests.h
1 #include <dballe/msg/tests.h>
2 #include <dballe/core/record.h>
3 #include <dballe/core/values.h>
4 #include <dballe/db/db.h>
5 #include <dballe/db/sql/driver.h>
6 
7 namespace dballe {
8 struct DB;
9 
10 namespace db {
11 struct Connection;
12 
13 namespace sql {
14 struct Driver;
15 }
16 namespace v6 {
17 class DB;
18 }
19 }
20 
21 namespace tests {
22 
23 Messages messages_from_db(DB& db, const dballe::Query& query);
24 Messages messages_from_db(DB& db, const char* query);
25 
27 {
28  dballe::db::Format old_format;
29  OverrideTestDBFormat(dballe::db::Format fmt);
31 };
32 
33 #if 0
34 template<typename T>
35 struct db_tg : public tut::test_group<T>
36 {
37  dballe::db::Format db_format;
38  const char* backend = 0;
39  const char* name;
40 
41  db_tg(const char* name, dballe::db::Format fmt, const char* backend=0)
42  : tut::test_group<T>(name), db_format(fmt), backend(backend), name(name)
43  {
44  }
45 
46  tut::test_result run_next()
47  {
49  return tut::test_group<T>::run_next();
50  }
51  tut::test_result run_test(int n)
52  {
54  return tut::test_group<T>::run_test(n);
55  }
56 };
57 #endif
58 
59 #if 0
60 struct TestStation
62 {
63  double lat;
64  double lon;
65  std::string ident;
67  std::map<std::string, core::Record> info;
68 
70  void set_latlonident_into(Record& rec) const;
71 
79  core::Record merged_info_with_highest_prio(DB& db) const;
80 
87  void insert(WIBBLE_TEST_LOCPRM, DB& db, bool can_replace=false);
88 };
89 
91 struct TestRecord
92 {
93  StationValues station;
95  core::Record data;
97  std::map<wreport::Varcode, core::Record> attrs;
99  int ana_id;
100 
103  void set_var(const char* msgvarname, double val, int conf=-1);
104 
105  void insert(WIBBLE_TEST_LOCPRM, DB& db, bool can_replace=false);
106 };
107 #endif
108 
111 {
113  std::map<std::string, StationValues> stations;
115  std::map<std::string, DataValues> data;
116 
117  TestDataSet() {}
118  virtual ~TestDataSet() {}
119 
120  virtual void populate_db(DB& db);
121 };
122 
125 {
127 };
128 
129 std::unique_ptr<db::Connection> get_test_connection(const std::string& backend);
130 
132 struct DriverFixture : public Fixture
133 {
134  std::string backend;
135  db::Format format;
136 
137  db::Connection* conn = nullptr;
138  db::sql::Driver* driver = nullptr;
139 
140  DriverFixture(const char* backend, db::Format format);
141  ~DriverFixture();
142 
143  void test_setup();
144 };
145 
146 #if 0
147 template<typename T=DriverFixture>
148 struct driver_test_group : public dballe::tests::test_group<T>
149 {
150  const char* backend;
151  db::Format dbformat;
152 
153  driver_test_group(const char* name, const char* backend, db::Format dbformat, const typename dballe::tests::test_group<T>::Tests& tests)
154  : dballe::tests::test_group<T>(name, tests), backend(backend), dbformat(dbformat)
155  {
156  }
157 
158  T* create_fixture()
159  {
160  DriverFixture::backend = backend;
161  DriverFixture::format = dbformat;
162  return dballe::tests::test_group<T>::create_fixture();
163  }
164 };
165 #endif
166 
167 struct DBFixture : public Fixture
168 {
169  std::string backend;
170  db::Format format;
171 
172  DB* db = nullptr;
173 
174  DBFixture(const char* backend, db::Format format);
175  ~DBFixture();
176 
178  std::unique_ptr<DB> create_db();
179 
180  void test_setup();
181 
182  template<typename DataSet>
183  void populate()
184  {
185  DataSet data_set;
186  wassert(populate_database(data_set));
187  }
188 
189  void populate_database(TestDataSet& data_set);
190 };
191 
192 #if 0
193 template<typename T=DBFixture>
194 struct db_test_group : public dballe::tests::test_group<T>
195 {
196  const char* backend;
197  db::Format dbformat;
198 
199  db_test_group(const char* name, const char* backend, db::Format dbformat, const typename dballe::tests::test_group<T>::Tests& tests)
200  : dballe::tests::test_group<T>(name, tests), backend(backend), dbformat(dbformat)
201  {
202  }
203 
204  T* create_fixture()
205  {
206  DBFixture::backend = backend;
207  DBFixture::format = dbformat;
208  return dballe::tests::test_group<T>::create_fixture();
209  }
210 };
211 #endif
212 
213 struct ActualCursor : public Actual<dballe::db::Cursor&>
214 {
215  using Actual::Actual;
216 
218  void station_keys_match(const Station& expected);
219 
221  void station_vars_match(const StationValues& expected);
222 
224  void data_context_matches(const DataValues& expected);
225 
227  void data_var_matches(const StationValues& expected, wreport::Varcode code) {
228  data_var_matches(*expected.values[code].var);
229  }
231  void data_var_matches(const DataValues& expected, wreport::Varcode code) {
232  data_var_matches(*expected.values[code].var);
233  }
235  void data_var_matches(const DataValues& expected) {
236  if (auto c = dynamic_cast<dballe::db::CursorValue*>(&_actual))
237  data_var_matches(*expected.values[c->get_varcode()].var);
238  else
239  throw wreport::error_consistency("cannot call data_var_matches on this kind of cursor");
240  }
242  void data_var_matches(const Values& expected, wreport::Varcode code) {
243  data_var_matches(*expected[code].var);
244  }
246  void data_var_matches(const wreport::Var& expected);
247 
249  void data_matches(const DataValues& ds)
250  {
251  if (auto c = dynamic_cast<dballe::db::CursorValue*>(&_actual))
252  data_matches(ds, c->get_varcode());
253  else
254  throw wreport::error_consistency("cannot call data_matches on this kind of cursor");
255  }
257  void data_matches(const DataValues& ds, wreport::Varcode code);
258 };
259 
260 typedef std::function<void(const std::vector<core::Record>&)> result_checker;
261 
262 struct ActualDB : public Actual<dballe::DB&>
263 {
264  using Actual::Actual;
265 
267  void try_data_query(const std::string& query, unsigned expected);
268 
270  void try_data_query(const Query& query, unsigned expected);
271 
273  void try_station_query(const std::string& query, unsigned expected);
274 
276  void try_summary_query(const std::string& query, unsigned expected, result_checker checker=nullptr);
277 };
278 
279 inline ActualCursor actual(dballe::db::Cursor& actual) { return ActualCursor(actual); }
280 inline ActualCursor actual(dballe::db::CursorStation& actual) { return ActualCursor(actual); }
281 inline ActualCursor actual(dballe::db::CursorStationData& actual) { return ActualCursor(actual); }
282 inline ActualCursor actual(dballe::db::CursorData& actual) { return ActualCursor(actual); }
283 inline ActualCursor actual(dballe::db::CursorSummary& actual) { return ActualCursor(actual); }
284 inline ActualCursor actual(std::unique_ptr<dballe::db::Cursor>& actual) { return ActualCursor(*actual); }
285 inline ActualCursor actual(std::unique_ptr<dballe::db::CursorStation>& actual) { return ActualCursor(*actual); }
286 inline ActualCursor actual(std::unique_ptr<dballe::db::CursorStationData>& actual) { return ActualCursor(*actual); }
287 inline ActualCursor actual(std::unique_ptr<dballe::db::CursorData>& actual) { return ActualCursor(*actual); }
288 inline ActualCursor actual(std::unique_ptr<dballe::db::CursorSummary>& actual) { return ActualCursor(*actual); }
289 inline ActualDB actual(dballe::DB& actual) { return ActualDB(actual); }
290 inline ActualDB actual(std::unique_ptr<dballe::DB>& actual) { return ActualDB(*actual); }
291 
292 }
293 }
void try_summary_query(const std::string &query, unsigned expected, result_checker checker=nullptr)
Check results of a summary query.
std::unique_ptr< DB > create_db()
Open a new DB with the backend and format specified in this fixture.
Cursor iterating over summary entries.
Definition: db.h:137
Cursor iterating over station data values.
Definition: db.h:119
Definition: values.h:12
void station_keys_match(const Station &expected)
Check cursor context after a query_stations.
Attribute table management used by the db module.
Definition: values.h:163
void data_var_matches(const DataValues &expected, wreport::Varcode code)
Check cursor data variable after a query_data.
Definition: db/tests.h:231
Copyright (C) 2008–2010 ARPA-SIM urpsim@smr.arpa.emr.it
Definition: cmdline.h:17
std::map< std::string, StationValues > stations
Arbitrarily named station values.
Definition: db/tests.h:113
void data_matches(const DataValues &ds)
Check cursor data context and variable after a query_data.
Definition: db/tests.h:249
Common interface for all kinds of cursors.
Definition: db.h:39
Functions used to connect to DB-All.e and insert, query and delete data.
Cursor iterating over stations.
Definition: db.h:98
Cursor iterating over data values.
Definition: db.h:124
Definition: db/tests.h:167
void data_context_matches(const DataValues &expected)
Check cursor data context after a query_data.
void data_var_matches(const Values &expected, wreport::Varcode code)
Check cursor data variable after a query_data.
Definition: db/tests.h:242
void station_vars_match(const StationValues &expected)
Check cursor context after a query_stations.
void try_data_query(const std::string &query, unsigned expected)
Check cursor data context anda variable after a query_data.
Definition: sql/driver.h:84
Definition: db.h:182
Definition: db/tests.h:26
void try_station_query(const std::string &query, unsigned expected)
Check results of a station query.
Query used to filter DB-All.e data.
Definition: query.h:14
void data_var_matches(const StationValues &expected, wreport::Varcode code)
Check cursor data variable after a query_data.
Definition: db/tests.h:227
Test fixture used by old DB-All.e db tests.
Definition: db/tests.h:124
Definition: values.h:142
Definition: db/tests.h:262
void data_var_matches(const DataValues &expected)
Check cursor data variable after a query_data.
Definition: db/tests.h:235
Base for datasets used to populate test databases.
Definition: db/tests.h:110
Definition: sql.h:69
std::map< std::string, DataValues > data
Arbitrarily named data values.
Definition: db/tests.h:115
Definition: values.h:106
Test fixture for SQL backend drivers.
Definition: db/tests.h:132
Definition: db/tests.h:213
Implement a storage object for a group of related observation data.