Merge pull request #686 from nygard89/master

[riak] Added new binding for Riak, based on the one created by Basho Technol…

.travis.yml

@@ -22,8 +22,8 @@ language: java
 jdk:
   - oraclejdk8
   - oraclejdk7
-  - openjdk7  
-  
+  - openjdk7
+
 install: mvn install -q -DskipTests=true
 
 script: mvn test -q
@@ -31,7 +31,8 @@ script: mvn test -q
 # Services to start for tests.
 services:
   - mongodb
+  - riak
 
 
 # Use the Container based infrastructure.
-sudo: false
+sudo: false
\ No newline at end of file

bin/ycsb

@@ -79,6 +79,7 @@ DATABASES = {
     "nosqldb"      : "com.yahoo.ycsb.db.NoSqlDbClient",
     "orientdb"     : "com.yahoo.ycsb.db.OrientDBClient",
     "redis"        : "com.yahoo.ycsb.db.RedisClient",
+    "riak"         : "com.yahoo.ycsb.db.riak.RiakKVClient",
     "s3"           : "com.yahoo.ycsb.db.S3Client",
     "solr"         : "com.yahoo.ycsb.db.SolrClient",
     "tarantool"    : "com.yahoo.ycsb.db.TarantoolClient",

distribution/pom.xml

@@ -149,6 +149,11 @@ LICENSE file.
       <artifactId>redis-binding</artifactId>
       <version>${project.version}</version>
     </dependency>
+    <dependency>
+      <groupId>com.yahoo.ycsb</groupId>
+      <artifactId>riak-binding</artifactId>
+      <version>${project.version}</version>
+    </dependency>
     <dependency>
       <groupId>com.yahoo.ycsb</groupId>
       <artifactId>s3-binding</artifactId>

pom.xml

@@ -93,6 +93,7 @@ LICENSE file.
     <couchbase.version>1.4.10</couchbase.version>
     <couchbase2.version>2.2.6</couchbase2.version>
     <tarantool.version>1.6.5</tarantool.version>
+    <riak.version>2.0.5</riak.version>
     <aerospike.version>3.1.2</aerospike.version>
     <solr.version>5.4.0</solr.version>
   </properties>
@@ -127,6 +128,7 @@ LICENSE file.
     <module>nosqldb</module>
     <module>orientdb</module>
     <module>redis</module>
+    <module>riak</module>
     <module>s3</module>
     <module>solr</module>
     <module>tarantool</module>

riak/README.md

+<!--
+Copyright (c) 2016 YCSB contributors. All rights reserved.
+Copyright 2014 Basho Technologies, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you
+may not use this file except in compliance with the License. You
+may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the specific language governing
+permissions and limitations under the License. See accompanying
+LICENSE file.
+-->
+
+Riak KV Client for Yahoo! Cloud System Benchmark (YCSB)
+=======================================================
+
+The Riak KV YCSB client is designed to work with the Yahoo! Cloud System Benchmark (YCSB) project (https://github.com/brianfrankcooper/YCSB) to support performance testing for the 2.x.y line of the Riak KV database.
+
+Creating a <i>bucket type</i> to use with YCSB
+----------------------------
+
+Perform the following operations on your Riak cluster to configure it for the benchmarks.
+
+Set the default backend for Riak to <i>LevelDB</i> in the `riak.conf` file of every node of your cluster. This is required to support <i>secondary indexes</i>, which are used for the `scan` transactions. You can do this by modifying the proper line as shown below.
+
+```
+storage_backend = leveldb
+```
+
+Now, create a bucket type named "ycsb"<sup id="a1">[1](#f1)</sup> by logging into one of the nodes in your cluster. Then, to use the <i>strong consistency model</i><sup id="a2">[2](#f2)</sup> (default), you need to follow the next two steps.
+
+1. In every `riak.conf` file, search for the `##strong_consistency=on` line and uncomment it. It's important that you do this <b>before you start your cluster</b>!
+2. Run the following `riak-admin` commands:
+
+  ```
+  riak-admin bucket-type create ycsb '{"props":{"consistent":true}}'
+  riak-admin bucket-type activate ycsb
+  ```
+
+Note that when using the strong consistency model, you **may have to specify the number of replicas to create for each object**. The *R* and *W* parameters (see next section) will in fact be ignored. The only information needed by this consistency model is how many nodes the system has to successfully query to consider a transaction completed. To set this parameter, you can add `"n_val":N` to the list of properties shown above (by default `N` is set to 3).
+
+If instead you want to use the <i>eventual consistency model</i> implemented in Riak, then type: 
+```
+riak-admin bucket-type create ycsb '{"props":{"allow_mult":"false"}}'
+riak-admin bucket-type activate ycsb
+```
+
+Riak KV configuration parameters
+----------------------------
+You can either specify these configuration parameters via command line or set them in the `riak.properties` file.
+
+* `riak.hosts` - <b>string list</b>, comma separated list of IPs or FQDNs. For example: `riak.hosts=127.0.0.1,127.0.0.2,127.0.0.3` or `riak.hosts=riak1.mydomain.com,riak2.mydomain.com,riak3.mydomain.com`.
+* `riak.port` - <b>int</b>, the port on which every node is listening. It must match the one specified in the `riak.conf` file at the line `listener.protobuf.internal`.
+* `riak.bucket_type` - <b>string</b>, it must match the name of the bucket type created during setup (see section above).
+* `riak.r_val` - <b>int</b>, this value represents the number of Riak nodes that must return results for a read operation before the transaction is considered successfully completed. 
+* `riak.w_val` - <b>int</b>, this value represents the number of Riak nodes that must report success before an insert/update transaction is considered complete.
+* `riak.read_retry_count` - <b>int</b>, the number of times the client will try to read a key from Riak.
+* `riak.wait_time_before_retry` - <b>int</b>, the time (in milliseconds) before the client attempts to perform another read if the previous one failed.
+* `riak.transaction_time_limit` - <b>int</b>, the time (in seconds) the client waits before aborting the current transaction.
+* `riak.strong_consistency` - <b>boolean</b>, indicates whether to use *strong consistency* (true) or *eventual consistency* (false).
+* `riak.debug` - <b>boolean</b>, enables debug mode. This displays all the properties (specified or defaults) when a benchmark is started. Moreover, it shows error causes whenever these occur.
+
+<b>Note</b>: For more information on workloads and how to run them please see: https://github.com/brianfrankcooper/YCSB/wiki/Running-a-Workload
+
+<b id="f1">1</b> As specified in the `riak.properties` file.  See parameters configuration section for further info. [↩](#a1)
+
+<b id="f2">2</b> <b>IMPORTANT NOTE:</b> Currently the `scan` transactions are <b>NOT SUPPORTED</b> for the benchmarks which use the strong consistency model! However this will not cause the benchmark to fail, it simply won't perform any scan transaction at all. These latter will immediately return with a `Status.NOT_IMPLEMENTED` code.  [↩](#a2)

riak/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+Copyright (c) 2016 YCSB contributors. All rights reserved.
+Copyright 2014 Basho Technologies, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you
+may not use this file except in compliance with the License. You
+may obtain a copy of the License at
+http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the specific language governing
+permissions and limitations under the License. See accompanying
+LICENSE file.
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>com.yahoo.ycsb</groupId>
+    <artifactId>binding-parent</artifactId>
+    <version>0.9.0-SNAPSHOT</version>
+    <relativePath>../binding-parent</relativePath>
+  </parent>
+
+  <artifactId>riak-binding</artifactId>
+  <name>Riak KV Binding</name>
+  <packaging>jar</packaging>
+
+  <dependencies>
+    <dependency>
+      <groupId>com.basho.riak</groupId>
+      <artifactId>riak-client</artifactId>
+      <version>2.0.5</version>
+    </dependency>
+    <dependency>
+      <groupId>com.yahoo.ycsb</groupId>
+      <artifactId>core</artifactId>
+      <version>${project.version}</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.google.collections</groupId>
+      <artifactId>google-collections</artifactId>
+      <version>1.0</version>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.12</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+</project>
\ No newline at end of file

riak/src/main/java/com/yahoo/ycsb/db/riak/RiakUtils.java

+/**
+ * Copyright (c) 2016 YCSB contributors All rights reserved.
+ * Copyright 2014 Basho Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you
+ * may not use this file except in compliance with the License. You
+ * may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * permissions and limitations under the License. See accompanying
+ * LICENSE file.
+ */
+
+package com.yahoo.ycsb.db.riak;
+
+import java.io.*;
+import java.util.Map;
+import java.util.Set;
+
+import com.yahoo.ycsb.ByteArrayByteIterator;
+import com.yahoo.ycsb.ByteIterator;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+/**
+ * Utility class for Riak KV Client.
+ *
+ */
+final class RiakUtils {
+
+  private RiakUtils() {
+    super();
+  }
+
+  private static byte[] toBytes(final int anInteger) {
+    byte[] aResult = new byte[4];
+
+    aResult[0] = (byte) (anInteger >> 24);
+    aResult[1] = (byte) (anInteger >> 16);
+    aResult[2] = (byte) (anInteger >> 8);
+    aResult[3] = (byte) (anInteger /* >> 0 */);
+
+    return aResult;
+  }
+
+  private static int fromBytes(final byte[] aByteArray) {
+    checkArgument(aByteArray.length == 4);
+
+    return (aByteArray[0] << 24) | (aByteArray[1] & 0xFF) << 16 | (aByteArray[2] & 0xFF) << 8 | (aByteArray[3] & 0xFF);
+  }
+
+  private static void close(final OutputStream anOutputStream) {
+    try {
+      anOutputStream.close();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+
+  private static void close(final InputStream anInputStream) {
+    try {
+      anInputStream.close();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+
+  /**
+   * Serializes a Map, transforming the contained list of (String, ByteIterator) couples into a byte array.
+   *
+   * @param aTable A Map to serialize.
+   * @return A byte array containng the serialized table.
+     */
+  static byte[] serializeTable(Map<String, ByteIterator> aTable) {
+    final ByteArrayOutputStream anOutputStream = new ByteArrayOutputStream();
+    final Set<Map.Entry<String, ByteIterator>> theEntries = aTable.entrySet();
+
+    try {
+      for (final Map.Entry<String, ByteIterator> anEntry : theEntries) {
+        final byte[] aColumnName = anEntry.getKey().getBytes();
+
+        anOutputStream.write(toBytes(aColumnName.length));
+        anOutputStream.write(aColumnName);
+
+        final byte[] aColumnValue = anEntry.getValue().toArray();
+
+        anOutputStream.write(toBytes(aColumnValue.length));
+        anOutputStream.write(aColumnValue);
+      }
+      return anOutputStream.toByteArray();
+    } catch (IOException e) {
+      throw new IllegalStateException(e);
+    } finally {
+      close(anOutputStream);
+    }
+  }
+
+  /**
+   * Deserializes an input byte array, transforming it into a list of (String, ByteIterator) couples (i.e. a Map).
+   *
+   * @param aValue    A byte array containing the table to deserialize.
+   * @param theResult A Map containing the deserialized table.
+     */
+  static void deserializeTable(final byte[] aValue, final Map<String, ByteIterator> theResult) {
+    final ByteArrayInputStream anInputStream = new ByteArrayInputStream(aValue);
+    byte[] aSizeBuffer = new byte[4];
+
+    try {
+      while (anInputStream.available() > 0) {
+        anInputStream.read(aSizeBuffer);
+        final int aColumnNameLength = fromBytes(aSizeBuffer);
+
+        final byte[] aColumnNameBuffer = new byte[aColumnNameLength];
+        anInputStream.read(aColumnNameBuffer);
+
+        anInputStream.read(aSizeBuffer);
+        final int aColumnValueLength = fromBytes(aSizeBuffer);
+
+        final byte[] aColumnValue = new byte[aColumnValueLength];
+        anInputStream.read(aColumnValue);
+
+        theResult.put(new String(aColumnNameBuffer), new ByteArrayByteIterator(aColumnValue));
+      }
+    } catch (Exception e) {
+      throw new IllegalStateException(e);
+    } finally {
+      close(anInputStream);
+    }
+  }
+
+  /**
+   * Obtains a Long number from a key string. This will be the key used by Riak for all the transactions.
+   *
+   * @param key The key to convert from String to Long.
+   * @return A Long number parsed from the key String.
+     */
+  static Long getKeyAsLong(String key) {
+    String keyString = key.replaceFirst("[a-zA-Z]*", "");
+
+    return Long.parseLong(keyString);
+  }
+}

riak/src/main/java/com/yahoo/ycsb/db/riak/package-info.java

+/**
+ * Copyright (c) 2016 YCSB contributors All rights reserved.
+ * Copyright 2014 Basho Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you
+ * may not use this file except in compliance with the License. You
+ * may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * permissions and limitations under the License. See accompanying
+ * LICENSE file.
+ */
+
+/**
+ * The YCSB binding for <a href="http://basho.com/products/riak-kv/">Riak KV</a> 2.x.y.
+ *
+ */
+package com.yahoo.ycsb.db.riak;
\ No newline at end of file

riak/src/main/resources/riak.properties

+##
+# Copyright (c) 2016 YCSB contributors All rights reserved.
+# Copyright 2014 Basho Technologies, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License. You
+# may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License. See accompanying
+# LICENSE file.
+#
+
+# RiakKVClient - Default Properties
+# Note: Change the properties below to set the values to use for your test. You can set them either here or from the
+# command line. Note that the latter choice overrides these settings.
+
+# riak.hosts - string list, comma separated list of IPs or FQDNs.
+# EX: 127.0.0.1,127.0.0.2,127.0.0.3 or riak1.mydomain.com,riak2.mydomain.com,riak3.mydomain.com
+riak.hosts=127.0.0.1
+
+# riak.port - int, the port on which every node is listening. It must match the one specified in the riak.conf file
+# at the line "listener.protobuf.internal".
+riak.port=8087
+
+# riak.bucket_type - string, must match value of bucket type created during setup. See readme.md for more information
+riak.bucket_type=ycsb
+
+# riak.r_val - int, the R value represents the number of Riak nodes that must return results for a read before the read
+# is considered successful.
+riak.r_val=2
+
+# riak.w_val - int, the W value represents the number of Riak nodes that must report success before an update is
+# considered complete.
+riak.w_val=2
+
+# riak.read_retry_count - int, number of times the client will try to read a key from Riak.
+riak.read_retry_count=5
+
+# riak.wait_time_before_retry - int, time (in milliseconds) the client waits before attempting to perform another
+# read if the previous one failed.
+riak.wait_time_before_retry=200
+
+# riak.transaction_time_limit - int, time (in seconds) the client waits before aborting the current transaction.
+riak.transaction_time_limit=10
+
+# riak.strong_consistency - boolean, indicates whether to use strong consistency (true) or eventual consistency (false).
+riak.strong_consistency=true
+
+# riak.debug - boolean, enables debug mode. This displays all the properties (specified or defaults) when a benchmark
+# is started.
+riak.debug=false
\ No newline at end of file

riak/src/test/java/com/yahoo/ycsb/db/riak/RiakKVClientTest.java

+/**
+ * Copyright (c) 2016 YCSB contributors All rights reserved.
+ * Copyright 2014 Basho Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you
+ * may not use this file except in compliance with the License. You
+ * may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * permissions and limitations under the License. See accompanying
+ * LICENSE file.
+ */
+
+package com.yahoo.ycsb.db.riak;
+
+import java.util.*;
+
+import com.yahoo.ycsb.ByteIterator;
+import com.yahoo.ycsb.Status;
+import com.yahoo.ycsb.StringByteIterator;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assume.assumeNoException;
+import static org.junit.Assume.assumeThat;
+
+/**
+ * Integration tests for the Riak KV client.
+ */
+public class RiakKVClientTest {
+  private static RiakKVClient riakClient;
+
+  private static final String bucket = "testBucket";
+  private static final String keyPrefix = "testKey";
+  private static final int recordsToInsert = 20;
+  private static final int recordsToScan = 7;
+  private static final String firstField = "Key number";
+  private static final String secondField = "Key number doubled";
+  private static final String thirdField = "Key number square";
+
+  private static boolean testStarted = false;
+
+  /**
+   * Creates a cluster for testing purposes.
+   */
+  @BeforeClass
+  public static void setUpClass() throws Exception {
+    riakClient = new RiakKVClient();
+    riakClient.init();
+
+    // Set the test bucket environment with the appropriate parameters.
+    try {
+      riakClient.setTestEnvironment(bucket);
+    } catch(Exception e) {
+      assumeNoException("Unable to configure Riak KV for test, aborting.", e);
+    }
+
+    // Just add some records to work on...
+    for (int i = 0; i < recordsToInsert; i++) {
+      // Abort the entire test whenever the dataset population operation fails.
+      assumeThat("Riak KV is NOT RUNNING, aborting test.",
+          riakClient.insert(bucket, keyPrefix + String.valueOf(i), StringByteIterator.getByteIteratorMap(
+              createExpectedHashMap(i))),
+              is(Status.OK));
+    }
+
+    // Variable to check to determine whether the test has started or not.
+    testStarted = true;
+  }
+
+  /**
+   * Shuts down the cluster created.
+   */
+  @AfterClass
+  public static void tearDownClass() throws Exception {
+    // Delete all added keys before cleanup ONLY IF TEST ACTUALLY STARTED.
+    if (testStarted) {
+      for (int i = 0; i <= recordsToInsert; i++) {
+        delete(keyPrefix + Integer.toString(i));
+      }
+    }
+
+    riakClient.cleanup();
+  }
+
+  /**
+   * Test method for read transaction. It is designed to read two of the three fields stored for each key, to also test
+   * if the createResultHashMap() function implemented in RiakKVClient.java works as expected.
+   */
+  @Test
+  public void testRead() {
+    // Choose a random key to read, among the available ones.
+    int readKeyNumber = new Random().nextInt(recordsToInsert);
+
+    // Prepare two fields to read.
+    Set<String> fields = new HashSet<>();
+    fields.add(firstField);
+    fields.add(thirdField);
+
+    // Prepare an expected result.
+    HashMap<String, String> expectedValue = new HashMap<>();
+    expectedValue.put(firstField, Integer.toString(readKeyNumber));
+    expectedValue.put(thirdField, Integer.toString(readKeyNumber * readKeyNumber));
+
+    // Define a HashMap to store the actual result.
+    HashMap<String, ByteIterator> readValue = new HashMap<>();
+
+    // If a read transaction has been properly done, then one has to receive a Status.OK return from the read()
+    // function. Moreover, the actual returned result MUST match the expected one.
+    assertEquals("Read transaction FAILED.",
+        Status.OK,
+        riakClient.read(bucket, keyPrefix + Integer.toString(readKeyNumber), fields, readValue));
+
+    assertEquals("Read test FAILED. Actual read transaction value is NOT MATCHING the expected one.",
+        expectedValue.toString(),
+        readValue.toString());
+  }
+
+  /**
+   * Test method for scan transaction. A scan transaction has to be considered successfully completed only if all the
+   * requested values are read (i.e. scan transaction returns with Status.OK). Moreover, one has to check if the
+   * obtained results match the expected ones.
+   */
+  @Test
+  public void testScan() {
+    // Choose, among the available ones, a random key as starting point for the scan transaction.
+    int startScanKeyNumber = new Random().nextInt(recordsToInsert - recordsToScan);
+
+    // Prepare a HashMap vector to store the scan transaction results.
+    Vector<HashMap<String, ByteIterator>> scannedValues = new Vector<>();
+
+    // Check whether the scan transaction is correctly performed or not.
+    assertEquals("Scan transaction FAILED.",
+        Status.OK,
+        riakClient.scan(bucket, keyPrefix + Integer.toString(startScanKeyNumber), recordsToScan, null,
+            scannedValues));
+
+    // After the scan transaction completes, compare the obtained results with the expected ones.
+    for (int i = 0; i < recordsToScan; i++) {
+      assertEquals("Scan test FAILED: the current scanned key is NOT MATCHING the expected one.",
+          createExpectedHashMap(startScanKeyNumber + i).toString(),
+          scannedValues.get(i).toString());
+    }
+  }
+
+  /**
+   * Test method for update transaction. The test is designed to restore the previously read key. It is assumed to be
+   * correct when, after performing the update transaction, one reads the just provided values.
+   */
+  @Test
+  public void testUpdate() {
+    // Choose a random key to read, among the available ones.
+    int updateKeyNumber = new Random().nextInt(recordsToInsert);
+
+    // Define a HashMap to save the previously stored values for eventually restoring them.
+    HashMap<String, ByteIterator> readValueBeforeUpdate = new HashMap<>();
+    riakClient.read(bucket, keyPrefix + Integer.toString(updateKeyNumber), null, readValueBeforeUpdate);
+
+    // Prepare an update HashMap to store.
+    HashMap<String, String> updateValue = new HashMap<>();
+    updateValue.put(firstField, "UPDATED");
+    updateValue.put(secondField, "UPDATED");
+    updateValue.put(thirdField, "UPDATED");
+
+    // First of all, perform the update and check whether it's failed or not.
+    assertEquals("Update transaction FAILED.",
+        Status.OK,
+        riakClient.update(bucket, keyPrefix + Integer.toString(updateKeyNumber), StringByteIterator
+            .getByteIteratorMap(updateValue)));
+
+    // Then, read the key again and...
+    HashMap<String, ByteIterator> readValueAfterUpdate = new HashMap<>();
+    assertEquals("Update test FAILED. Unable to read key value.",
+        Status.OK,
+        riakClient.read(bucket, keyPrefix + Integer.toString(updateKeyNumber), null, readValueAfterUpdate));
+
+    // ...compare the result with the new one!
+    assertEquals("Update transaction NOT EXECUTED PROPERLY. Values DID NOT CHANGE.",
+        updateValue.toString(),
+        readValueAfterUpdate.toString());
+
+    // Finally, restore the previously read key.
+    assertEquals("Update test FAILED. Unable to restore previous key value.",
+        Status.OK,
+        riakClient.update(bucket, keyPrefix + Integer.toString(updateKeyNumber), readValueBeforeUpdate));
+  }
+
+  /**
+   * Test method for insert transaction. It is designed to insert a key just after the last key inserted in the setUp()
+   * phase.
+   */
+  @Test
+  public void testInsert() {
+    // Define a HashMap to insert and another one for the comparison operation.
+    HashMap<String, String> insertValue = createExpectedHashMap(recordsToInsert);
+    HashMap<String, ByteIterator> readValue = new HashMap<>();
+
+    // Check whether the insertion transaction was performed or not.
+    assertEquals("Insert transaction FAILED.",
+        Status.OK,
+        riakClient.insert(bucket, keyPrefix + Integer.toString(recordsToInsert), StringByteIterator.
+            getByteIteratorMap(insertValue)));
+
+    // Finally, compare the insertion performed with the one expected by reading the key.
+    assertEquals("Insert test FAILED. Unable to read inserted value.",
+        Status.OK,
+        riakClient.read(bucket, keyPrefix + Integer.toString(recordsToInsert), null, readValue));
+    assertEquals("Insert test FAILED. Actual read transaction value is NOT MATCHING the inserted one.",
+        insertValue.toString(),
+        readValue.toString());
+  }
+
+  /**
+   * Test method for delete transaction. The test deletes a key, then performs a read that should give a
+   * Status.NOT_FOUND response. Finally, it restores the previously read key.
+   */
+  @Test
+  public void testDelete() {
+    // Choose a random key to delete, among the available ones.
+    int deleteKeyNumber = new Random().nextInt(recordsToInsert);
+
+    // Define a HashMap to save the previously stored values for its eventual restore.
+    HashMap<String, ByteIterator> readValueBeforeDelete = new HashMap<>();
+    riakClient.read(bucket, keyPrefix + Integer.toString(deleteKeyNumber), null, readValueBeforeDelete);
+
+    // First of all, delete the key.
+    assertEquals("Delete transaction FAILED.",
+        Status.OK,
+        delete(keyPrefix + Integer.toString(deleteKeyNumber)));
+
+    // Then, check if the deletion was actually achieved.
+    assertEquals("Delete test FAILED. Key NOT deleted.",
+        Status.NOT_FOUND,
+        riakClient.read(bucket, keyPrefix + Integer.toString(deleteKeyNumber), null, null));
+
+    // Finally, restore the previously deleted key.
+    assertEquals("Delete test FAILED. Unable to restore previous key value.",
+        Status.OK,
+        riakClient.insert(bucket, keyPrefix + Integer.toString(deleteKeyNumber), readValueBeforeDelete));
+  }
+
+  private static Status delete(String key) {
+    return riakClient.delete(bucket, key);
+  }
+
+  private static HashMap<String, String> createExpectedHashMap(int value) {
+    HashMap<String, String> values = new HashMap<>();
+
+    values.put(firstField, Integer.toString(value));
+    values.put(secondField, Integer.toString(2 * value));
+    values.put(thirdField, Integer.toString(value * value));
+
+    return values;
+  }
+}