Ejemplo n.º 1
0
func (self *Converter) WriteBlob(input []byte) interface{} {
	if input == nil {
		panic("Expecting blob but value is missing")
	}
	if self.BlobAsBinary {
		return input
	} else {
		return encoding.Base64Encode(input)
	}
}
Ejemplo n.º 2
0
func (self *Converter) WriteValue(input types.Array) interface{} {
	if input == nil {
		panic("Expecting value but value is missing")
	}
	if self.ValueAsBinary {
		return input.ToBytesArray()
	} else {
		arrayOfStrings := make([]string, len(input))
		for index, element := range input {
			arrayOfStrings[index] = encoding.Base64Encode([]byte(element))
		}
		return arrayOfStrings
	}
}
Ejemplo n.º 3
0
func TestSimpleBlobStoreWrite(t *testing.T) {
	bucketId := createBucket(t, TypeId_BlobStore)
	arguments := make(map[string]interface{})

	// Put something
	// 'VGhpcyBpcyBhIHRlc3Q' = "This is a test"
	putToBlob := &testframework.JsonTest{
		Input: fmt.Sprintf(`{
			"Operation" : "Put",
			"Data" : {
				"BucketId" : "%v",
				"Key" : "incubation/test1/append",
				"Value" : "VGhpcyBpcyBhIHRlc3Q"
			}}`, bucketId),
		Expect: `{
			"Code" : "!(retcode_ok)!"
		}`,
	}
	runner().Run(t, putToBlob)

	// Now get the sha256 hash
	getSha256Hash := &testframework.JsonTest{
		Input: fmt.Sprintf(`{
			"Operation" : "Get",
			"Data" : {
				"BucketId" : "%v",
				"Key" : "incubation/test1/sum"
			}}`, bucketId),
		Expect: `{
			"Code" : "!(retcode_ok_found)!",
			"Data" : {
				"Value" : ["!(string_not_empty:cbor_hash)!",
					 "!(string_not_empty:cbor_length)!"]
			}
		}`,
		Arguments: arguments,
	}
	runner().Run(t, getSha256Hash)
	if t.Failed() {
		return
	}

	// See if the data we got is correct
	hashCborBase64 := arguments["cbor_hash"].(string)
	lengthCBorBase64 := arguments["cbor_length"].(string)
	hashCBor, err := encoding.Base64Decode(hashCborBase64)

	lengthCBor, err := encoding.Base64Decode(lengthCBorBase64)
	var hash []byte
	err = encoding.Cbor().Decode(hashCBor, &hash)
	var length uint64
	err = encoding.Cbor().Decode(lengthCBor, &length)
	if err != nil {
		t.Fatal(err)
	}

	// Length of "This is a test"
	if length != 14 {
		t.Fatalf("Expecting the length to be 14 but it's %v\n", length)
	}
	// Just check the hash length. TODO: Also check content
	if len(hash) != 32 {
		t.Fatalf("Since it's SHA256 (256 bits) the hash has to be 32 bytes,"+
			" but is %v\n", len(hash))
	}

	// Now finish it (will make it accessible to the public)
	putFinish := &testframework.JsonTest{
		Input: fmt.Sprintf(`{
			"Operation" : "Put",
			"Data" : {
				"BucketId" : "%v",
				"Key" : "incubation/test1/finish"
			}}`, bucketId),
		Expect: `{
			"Code" : "!(retcode_ok)!"
		}`,
	}
	runner().Run(t, putFinish)

	// It now should be possible to access the data using the hash

	// First get the length
	hashAsBase64 := encoding.Base64Encode(hash)
	getLength := &testframework.JsonTest{
		Input: fmt.Sprintf(`{
			"Operation" : "Get",
			"Data" : {
				"BucketId" : "%v",
				"Key" : "hash/:base64:%v/length"
			}}`, bucketId, hashAsBase64),
		Expect: `{
			"Code" : "!(retcode_ok_found)!",
			"Data" : {
				"Value" : ["!(string_not_empty:cbor_length)!"]
			}
		}`,
		Arguments: arguments,
	}
	runner().Run(t, getLength)

	// Again, check the length
	lengthCBorBase64 = arguments["cbor_length"].(string)
	lengthCBor, err = encoding.Base64Decode(lengthCBorBase64)
	err = encoding.Cbor().Decode(lengthCBor, &length)
	if err != nil {
		t.Fatal(err)
	}
	if length != 14 {
		t.Fatalf("The length should still be 14 but it's %v\n", length)
	}

	// Now read from it
	// Skip is set to 0
	// Limit is set to 14 (should read everything we have)
	getData := &testframework.JsonTest{
		Input: fmt.Sprintf(`{
			"Operation" : "Get",
			"Data" : {
				"BucketId" : "%v",
				"Key" : "hash/:base64:%v/content/:uvarint:0/:uvarint:14"
			}}`, bucketId, hashAsBase64),
		Expect: `{
			"Code" : "!(retcode_ok_found)!",
			"Data" : {
				"Value" : [
					"!(string_not_empty:data)!",
					"!(string_not_empty:cbor_length)!"
				]
			}
		}`,
		Arguments: arguments,
	}
	runner().Run(t, getData)

	// Ok, now check if we got the correct data
	dataAsBase64 := arguments["data"].(string)
	dataAsBinary, err := encoding.Base64Decode(dataAsBase64)
	if err != nil {
		t.Fatal(err)
	}
	// The data we originally added
	if string(dataAsBinary) != "This is a test" {
		t.Fatalf("Got wrong data '%v'. Expecting 'This is a test'",
			string(dataAsBinary))
	}
}