Add WithMeta unit tests
[ep-engine.git] / tests / module_tests / kv_bucket_test.h
1 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2 /*
3  *     Copyright 2016 Couchbase, Inc
4  *
5  *   Licensed under the Apache License, Version 2.0 (the "License");
6  *   you may not use this file except in compliance with the License.
7  *   You may obtain a copy of the License at
8  *
9  *       http://www.apache.org/licenses/LICENSE-2.0
10  *
11  *   Unless required by applicable law or agreed to in writing, software
12  *   distributed under the License is distributed on an "AS IS" BASIS,
13  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  *   See the License for the specific language governing permissions and
15  *   limitations under the License.
16  */
17
18 /*
19  * Unit tests for the KVBucket class.
20  *
21  * These tests are instantiated with additional config strings to test over
22  * ephemeral and value and full eviction persistent buckets.
23  *
24  */
25
26 #pragma once
27
28 #include "config.h"
29
30 #include "ep_bucket.h"
31 #include "ep_engine.h"
32 #include "item.h"
33
34 #include <memcached/engine.h>
35 #include <tests/mock/mock_synchronous_ep_engine.h>
36
37 #include <gtest/gtest.h>
38 #include <memory>
39
40 /**
41  * Test fixture for KVBucket unit tests.
42  *
43  * Will create the appropriate subclass of KVBucket (EPBucket /
44  * EphemeralBucket) based on the Configuration passed (specifically the
45  * bucket_type parameter), defaulting to EPBucket if no bucket_type is
46  * specified.
47  */
48 class KVBucketTest : public ::testing::Test {
49 public:
50     void SetUp() override;
51
52     void TearDown() override;
53
54     // Stores an item into the given vbucket. Returns the item stored.
55     Item store_item(uint16_t vbid,
56                     const StoredDocKey& key,
57                     const std::string& value,
58                     uint32_t exptime = 0,
59                     const std::vector<cb::engine_errc>& expected =
60                             {cb::engine_errc::success},
61                     protocol_binary_datatype_t datatype =
62                             PROTOCOL_BINARY_DATATYPE_JSON);
63
64     /**
65      * Store multiple items into the vbucket, the given key will have an
66      * iteration appended to it.
67      */
68     ::testing::AssertionResult store_items(
69             int nitems,
70             uint16_t vbid,
71             const DocKey& key,
72             const std::string& value,
73             uint32_t exptime = 0,
74             protocol_binary_datatype_t datatype =
75                     PROTOCOL_BINARY_DATATYPE_JSON);
76
77     /* Flush the given vbucket to disk, so any outstanding dirty items are
78      * written (and are clean).
79      */
80     void flush_vbucket_to_disk(uint16_t vbid, int expected = 1);
81
82     /* Delete the given item from the given vbucket, verifying it was
83      * successfully deleted.
84      */
85     void delete_item(uint16_t vbid, const StoredDocKey& key);
86
87     /* Evict the given key from memory according to the current eviction
88      * strategy. Verifies it was successfully evicted.
89      */
90     void evict_key(uint16_t vbid, const StoredDocKey& key);
91
92     /// Exposes the normally-protected getInternal method from the store.
93     GetValue getInternal(const StoredDocKey& key,
94                          uint16_t vbucket,
95                          const void* cookie,
96                          vbucket_state_t allowedState,
97                          get_options_t options);
98
99     /**
100      * Creates the ItemPager task and adds it to the scheduler. Allows testing
101      * of the item pager from subclasses, without KVBucket having to grant
102      * friendship to many different test classes.
103      */
104     void createAndScheduleItemPager();
105
106     void initializeExpiryPager();
107
108     /**
109      * Create a *_with_meta packet with the key/body
110      * Allows *_with_meta to be invoked via EventuallyPersistentEngine which
111      * begins with a packet
112      */
113     static std::vector<char> buildWithMetaPacket(
114             protocol_binary_command opcode,
115             protocol_binary_datatype_t datatype,
116             uint16_t vbucket,
117             uint32_t opaque,
118             uint64_t cas,
119             ItemMetaData metaData,
120             const std::string& key,
121             const std::string& body,
122             const std::vector<char>& emd = {},
123             int options = 0);
124
125     static bool addResponse(const void* k,
126                             uint16_t keylen,
127                             const void* ext,
128                             uint8_t extlen,
129                             const void* body,
130                             uint32_t bodylen,
131                             uint8_t datatype,
132                             uint16_t status,
133                             uint64_t pcas,
134                             const void* cookie);
135
136     /**
137      * Create an XATTR document using the supplied string as the body
138      * @returns string containing the new value
139      */
140     static std::string createXattrValue(const std::string& body);
141
142     static protocol_binary_response_status getAddResponseStatus(
143             protocol_binary_response_status newval =
144                     PROTOCOL_BINARY_RESPONSE_SUCCESS);
145
146     static protocol_binary_response_status addResponseStatus;
147
148     static const char test_dbname[];
149
150     std::string config_string;
151
152     const uint16_t vbid = 0;
153
154     // The mock engine (needed to construct the store).
155     std::unique_ptr<SynchronousEPEngine> engine;
156
157     // The store under test. Wrapped in a mock to expose some normally
158     // protected members. Uses a raw pointer as this is owned by the engine.
159     KVBucket* store;
160
161     // The (mock) server cookie.
162     const void* cookie;
163 };
164
165 /**
166  * Test fixture for KVBucket unit tests.
167  *
168  * These tests are parameterized over an extra config string to allow them to
169  * be run against ephemeral and value and full eviction persistent buckets.
170  */
171 class KVBucketParamTest : public KVBucketTest,
172                           public ::testing::WithParamInterface<std::string> {
173     void SetUp() override {
174         config_string += GetParam();
175         KVBucketTest::SetUp();
176
177         // Have all the objects, activate vBucket zero so we can store data.
178         store->setVBucketState(vbid, vbucket_state_active, false);
179     }
180 };