public void ConflictOnNonMultiBucket()
{
RiakClient client = new RiakClient(Settings.RiakServerUri);
Bucket bucket = client.Bucket("NonMultiBucket");
Assert.IsFalse(bucket.AllowMulti);
RiakObject keyToConflictOn = bucket.Get(Guid.NewGuid().ToString());
keyToConflictOn.ContentType = "text/plain";
keyToConflictOn.Store("Data1");
RiakObject conflict1 = bucket.Get(keyToConflictOn.KeyName);
Util.ReadString(conflict1.Data());
RiakObject conflict2 = bucket.Get(keyToConflictOn.KeyName);
Util.ReadString(conflict2.Data());
Assert.IsNotNull(conflict1.VClock);
Assert.AreEqual(conflict1.VClock, conflict2.VClock);
conflict1.Store("Conflict1");
conflict2.Store("Conflict2");
keyToConflictOn.Refresh();
Assert.AreEqual(Util.ReadString(keyToConflictOn.Data()), "Conflict2");
}
internal Bucket(RiakClient client, string bucketName)
{
Streaming = true;
Client = client;
Name = bucketName;
_keys = new List<string>();
Links = new LinkCollection();
}
public void GetAutoAssignedId()
{
RiakClient client = new RiakClient(Settings.RiakServerUri);
Bucket bucket = client.Bucket("RiakObjectTest");
RiakObject o1 = bucket.GetNew();
o1.ContentType = "text/html";
string storedValue = Guid.NewGuid().ToString();
o1.Store(storedValue);
// the name should be auto-assigned to something valid
Assert.IsNotNull(o1.KeyName);
Assert.AreEqual(storedValue, Util.ReadString(o1.Data()));
}
public void ConflictsFromUniqueClientsWithVClock()
{
string BucketName = Guid.NewGuid().ToString();
string KeyName = Guid.NewGuid().ToString();
RiakClient startClient = new RiakClient(Settings.RiakServerUri);
Bucket startBucket = startClient.Bucket(BucketName);
startBucket.SetAllowMulti(true);
RiakObject startKey = startBucket.Get(KeyName);
startKey.ContentType = "text/plain";
startKey.Store(Guid.NewGuid().ToString());
List<RiakClient> clients = new List<RiakClient>();
clients.Add(new RiakClient(Settings.RiakServerUri));
clients.Add(new RiakClient(Settings.RiakServerUri));
clients.Add(new RiakClient(Settings.RiakServerUri));
clients.Add(new RiakClient(Settings.RiakServerUri));
List<RiakObject> conflicts = new List<RiakObject>();
foreach(RiakClient client in clients)
{
Bucket b = client.Bucket(BucketName);
Assert.IsTrue(b.AllowMulti);
conflicts.Add(b.Get(KeyName));
}
foreach(RiakObject key in conflicts)
{
Assert.IsNotNull(key.VClock);
key.Store(Guid.NewGuid().ToString());
}
RiakClient verifyClient = new RiakClient(Settings.RiakServerUri);
Bucket bucket = verifyClient.Bucket(BucketName);
ICollection<RiakObject> verifyConflicts = bucket.GetAll(KeyName, false);
Assert.AreEqual(4, verifyConflicts.Count);
foreach(RiakObject ro in verifyConflicts)
{
Assert.AreEqual("text/plain", ro.ContentType);
string content = ro.DataString();
Assert.IsNotNull(content);
Assert.AreEqual(ro.ContentLength, content.Length);
}
}
public void LinkFollowing()
{
RiakClient client = new RiakClient(Settings.RiakServerUri);
Bucket artist = client.Bucket("Artist");
TestUtil.DeleteAllKeys(artist);
RiakObject miles = CreateTextObject(artist, "Miles Davis");
Bucket album = client.Bucket("Album");
TestUtil.DeleteAllKeys(album);
RiakObject kindofblue = CreateTextObject(album, "Kind of Blue");
RiakObject conception = CreateTextObject(album, "Conception");
RiakObject blue = CreateTextObject(album, "Blue");
RiakObject dig = CreateTextObject(album, "Dig");
miles.AddLink(kindofblue, "album");
miles.AddLink(conception, "album");
miles.AddLink(blue, "album");
miles.AddLink(dig, "album");
miles.Store();
kindofblue.AddLink(miles, "artist");
kindofblue.Store();
conception.AddLink(miles, "artist");
conception.Store();
blue.AddLink(miles, "artist");
blue.Store();
dig.AddLink(miles, "artist");
dig.Store();
RiakObject loadedMiles = artist.Get("Miles Davis");
Assert.AreEqual("Miles Davis", loadedMiles.KeyName);
// the 4 we added plus the rel="up" for the key
Assert.AreEqual(5, loadedMiles.Links.Count);
Assert.AreEqual(4, loadedMiles.Links.Count(l => l.RiakTag != null));
Assert.AreEqual(0, loadedMiles.Links.Count(l => l.RiakTag != null && l.RiakTag != "album"));
}
public void MRTest1()
{
Assert.Inconclusive("This test is not ready yet.");
RiakClient c = new RiakClient(Settings.RiakServerUri);
Bucket b = c.Bucket("Missing");
// function(value, keyData, arg) { var data = Riak.mapValuesJson(value); return [data[0]]; }
MapReduce mr1 = new MapReduce()
.Input(b)
.Map(new Phase(
new JsonFunction(
"function(value, keyData, arg) { var data = Riak.mapValuesJson(value); return [data[0]]; }")))
.Reduce(new Phase(
new JsonFunction("function(value) { return [value]; }"))
{
Keep = true
});
RiakHttpResponse response = mr1.Run();
}
public void GetAllTextData()
{
string _multiPartBucket = Guid.NewGuid().ToString();
const string AllTextKeyName = "AllTextKey";
_randomTextData = new List<string>();
RiakClient client = new RiakClient(Settings.RiakServerUri);
Bucket bucket = client.Bucket(_multiPartBucket);
TestUtil.DeleteAllKeys(bucket);
bucket.SetAllowMulti(true);
RiakObject key1 = bucket.Get(AllTextKeyName);
RiakObject key2 = bucket.Get(AllTextKeyName);
RiakObject key3 = bucket.Get(AllTextKeyName);
RiakObject key4 = bucket.Get(AllTextKeyName);
SetAndStoreTextKey(key1);
SetAndStoreTextKey(key2);
SetAndStoreTextKey(key3);
SetAndStoreTextKey(key4);
client = new RiakClient(Settings.RiakServerUri);
bucket = client.Bucket(_multiPartBucket);
ICollection<RiakObject> conflicts = bucket.GetAll(AllTextKeyName, false);
// whoa! Why 2? Because we're using the same client ID for all
// of these objects so the Riak server is going to throw away all
// but the last two conflicts.
Assert.AreEqual(2, conflicts.Count);
foreach(RiakObject ro in conflicts)
{
Assert.AreEqual("text/plain", ro.ContentType);
string content = ro.DataString();
Assert.IsNotNull(content);
Assert.IsTrue(_randomTextData.Contains(content));
Assert.AreEqual(ro.ContentLength, content.Length);
}
}
public void DeleteExistingKeys()
{
RiakClient client = new RiakClient(Settings.RiakServerUri);
Bucket bucket = client.Bucket("BucketTest");
if (bucket.Keys.Count == 0)
{
RiakObject o1 = bucket.Get("SomeKey");
o1.ContentType = "text/plain";
o1.Store(Guid.NewGuid().ToString());
}
bucket.Refresh();
Assert.IsTrue(bucket.Keys.Count > 0);
foreach(string key in bucket.Keys)
{
bucket.Get(key).Delete();
}
bucket.Refresh();
Assert.AreEqual(0, bucket.Keys.Count);
}
public void SettingAllowMultiPersistsCorrectly()
{
RiakClient client = new RiakClient(Settings.RiakServerUri);
Bucket bucket = client.Bucket("SettingAllowMultiPersistsCorrectly");
bucket.SetAllowMulti(true);
Assert.IsTrue(bucket.AllowMulti);
bucket.Refresh();
Assert.IsTrue(bucket.AllowMulti);
bucket.SetAllowMulti(false);
Assert.IsFalse(bucket.AllowMulti);
bucket.Refresh();
Assert.IsFalse(bucket.AllowMulti);
bucket.SetAllowMulti(true);
Assert.IsTrue(bucket.AllowMulti);
bucket.Refresh();
Assert.IsTrue(bucket.AllowMulti);
}
public void SaveAStringKeyValue()
{
RiakClient client = new RiakClient(Settings.RiakServerUri);
Bucket bucket = client.Bucket("BucketTest");
Assert.IsFalse(bucket.AllowMulti);
RiakObject o1 = bucket.Get("StringKey");
o1.ContentType = "text/html";
string storedValue = Guid.NewGuid().ToString();
o1.Store(storedValue);
Assert.AreEqual(storedValue, Util.ReadString(o1.Data()));
}
public void SaveABinaryKeyValue()
{
RiakClient client = new RiakClient(Settings.RiakServerUri);
Bucket bucket = client.Bucket("BucketTest");
Assert.IsFalse(bucket.AllowMulti);
RiakObject o1 = bucket.Get("BinaryKey");
o1.ContentType = "application/binary";
const string referenceString = "Sample Stream Data";
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(referenceString)))
{
o1.Store(ms);
string newString = Util.ReadString(o1.Data());
Assert.AreEqual(referenceString, newString);
}
o1.Refresh();
Assert.AreEqual("application/binary", o1.ContentType);
}
public void GetAllSiblingsOnConflict()
{
RiakClient client = new RiakClient(Settings.RiakServerUri);
Bucket bucket = client.Bucket("ConflictOnAllowMultiBucket");
bucket.SetAllowMulti(true);
RiakObject keyToConflictOn = bucket.Get(Guid.NewGuid().ToString());
keyToConflictOn.ContentType = "text/plain";
keyToConflictOn.Store("Data1");
RiakObject conflict1 = bucket.Get(keyToConflictOn.KeyName);
Util.ReadString(conflict1.Data());
RiakObject conflict2 = bucket.Get(keyToConflictOn.KeyName);
Util.ReadString(conflict2.Data());
Assert.IsNotNull(conflict1.VClock);
Assert.AreEqual(conflict1.VClock, conflict2.VClock);
conflict1.Store("Conflict1");
conflict2.Store("Conflict2");
keyToConflictOn.Refresh();
Assert.IsTrue(keyToConflictOn.HasSiblings);
conflict1.Refresh();
Assert.IsTrue(conflict1.HasSiblings);
conflict2.Refresh();
Assert.IsTrue(conflict2.HasSiblings);
ICollection<RiakObject> siblings = bucket.GetAll(keyToConflictOn.KeyName);
Assert.AreEqual(2, siblings.Count);
string string0 = Util.ReadString(siblings.ElementAt(0).Data());
string string1 = Util.ReadString(siblings.ElementAt(1).Data());
List<string> expect = new List<string>{"Conflict1", "Conflict2"};
Assert.IsTrue(expect.Contains(string0));
Assert.IsTrue(expect.Contains(string1));
}
public void DeleteMissingKeys()
{
RiakClient client = new RiakClient(Settings.RiakServerUri);
Bucket bucket = client.Bucket("BucketTest");
for (int i = 0; i < 10; i++)
{
RiakObject o1 = bucket.Get(i.ToString());
o1.ContentType = "text/plain";
o1.Store(Guid.NewGuid().ToString());
}
bucket.Refresh();
for (int i = 0; i < 10; i++)
{
RiakObject o1 = bucket.Get(i.ToString());
o1.Delete(); // returns 204
o1.Delete(); // returns 404
}
for (int i = 0; i < 10; i++)
{
// allocates a new/missing key
RiakObject o1 = bucket.Get(i.ToString());
o1.Delete(); // returns 404
}
}
public void LinkOnNewKeyExistsAndParses()
{
// setup a bucket with a key
RiakClient client = new RiakClient(Settings.RiakServerUri);
Bucket bucket = client.Bucket("BucketTest");
Assert.IsFalse(bucket.AllowMulti);
RiakObject o1 = bucket.Get("StringKey");
o1.ContentType = "text/plain";
string storedValue = Guid.NewGuid().ToString();
o1.Store(storedValue);
Assert.AreEqual(storedValue, Util.ReadString(o1.Data()));
// the key should have one link back to the bucket.
o1.Refresh();
Assert.AreEqual(1, o1.Links.Count);
Assert.IsNotNull(o1.Links[0].Rel);
Assert.AreEqual("up", o1.Links[0].Rel);
}
