func TestMockExecutorPutItem(t *testing.T) {
	assert, client, executor := mockSetup(t)
	client.PutItem("table2", dynago.HashKey("Id", 5)).
		ConditionExpression("Foo = :bar").Param(":bar", "45").
		ReturnValues(dynago.ReturnUpdatedNew).
		Execute()
	assert.Equal(true, executor.PutItemCalled)
	assert.Equal("PutItem", executor.PutItemCall.Method)
	assert.Equal("table2", executor.PutItemCall.Table)
	assert.Equal(dynago.HashKey("Id", 5), executor.PutItemCall.Item)
	assert.Equal(dynago.ReturnUpdatedNew, executor.PutItemCall.ReturnValues)
	assert.Equal(executor.Calls[0], *executor.PutItemCall)
}
Beispiel #2
0
func TestDeleteItem_functional(t *testing.T) {
	assert, client := funcTest.setUp(t)
	_, err := client.PutItem("Person", person(47, "Mary")).Execute()
	assert.NoError(err)

	key := dynago.HashKey("Id", 47)
	di := client.DeleteItem("Person", key).
		ConditionExpression("#n <> :name", dynago.Param{"#n", "Name"}, dynago.Param{":name", "Mary"}).
		ReturnValues(dynago.ReturnAllOld)
	result, err := di.Execute()
	assert.Nil(result)
	assert.NotNil(err)
	e := err.(*dynago.Error)
	assert.Equal(dynago.ErrorConditionFailed, e.Type)

	result, err = di.ConditionExpression("#n <> :name", dynago.Param{":name", "Albert"}).Execute()
	assert.NoError(err)
	assert.NotNil(result)
	doc := dynago.Document{"Name": "Mary", "IncVal": dynago.Number("1"), "Id": dynago.Number("47")}
	assert.Equal(doc, result.Attributes)

	result, err = di.ReturnValues(dynago.ReturnNone).Execute()
	assert.Nil(err)
	assert.Nil(result)
}
func TestMockExecutorDeleteItem(t *testing.T) {
	assert, client, executor := mockSetup(t)
	client.DeleteItem("table1", dynago.HashKey("Id", 51)).
		ConditionExpression("expr1", dynago.Param{":foo", 4}, dynago.Param{"#f", "f"}).
		ReturnValues(dynago.ReturnAllOld).
		Execute()
	assert.Equal(true, executor.DeleteItemCalled)
	assert.Equal(executor.Calls[0], *executor.DeleteItemCall)
	call := executor.DeleteItemCall
	assert.Equal("DeleteItem", call.Method)
	assert.Equal(dynago.HashKey("Id", 51), call.Key)
	assert.Equal("table1", call.Table)
	assert.Equal("expr1", call.ConditionExpression)
	assert.Equal(dynago.ReturnAllOld, call.ReturnValues)
	assert.Equal(dynago.Document{":foo": 4}, call.ExpressionAttributeValues)
	assert.Equal(map[string]string{"#f": "f"}, call.ExpressionAttributeNames)
}
Beispiel #4
0
func TestBatchWrite(t *testing.T) {
	assert, client := funcTest.setUp(t)
	_, err := client.PutItem("Person", person(4, "ToDelete")).Execute()
	assert.NoError(err)

	p1 := person(1, "Joe")
	p2 := person(2, "Mary")
	p3 := person(3, "Amy")
	_, err = client.BatchWrite().
		Put("Person", p1, p2, p3).
		Delete("Person", dynago.HashKey("Id", 4)).
		Execute()

	assert.NoError(err)

	response, err := client.GetItem("Person", dynago.HashKey("Id", 2)).Execute()
	assert.Equal("Mary", response.Item["Name"])
}
func TestMockExecutorBatchWriteItem(t *testing.T) {
	assert, client, executor := mockSetup(t)
	doc1 := dynago.Document{"Id": 1, "Name": "1"}
	doc2 := dynago.Document{"Id": 2, "Name": "2"}
	key3 := dynago.HashKey("Id", 3)
	key4 := dynago.HashKey("Id", 4)
	client.BatchWrite().
		Put("table1", doc1, doc2).
		Delete("table1", key3).
		Delete("table2", key4).
		Execute()
	assert.Equal(true, executor.BatchWriteItemCalled)
	assert.Equal([]dynago.Document{doc2, doc1}, executor.BatchWriteItemCall.BatchWrites.GetPuts("table1"))
	assert.Equal(0, len(executor.BatchWriteItemCall.BatchWrites.GetPuts("table2")))
	assert.Equal([]dynago.Document{key3}, executor.BatchWriteItemCall.BatchWrites.GetDeleteKeys("table1"))
	assert.Equal([]dynago.Document{key4}, executor.BatchWriteItemCall.BatchWrites.GetDeleteKeys("table2"))
	assert.Equal(executor.Calls[0], *executor.BatchWriteItemCall)
}
func ExampleClient_UpdateItem(client *dynago.Client) {
	_, err := client.UpdateItem("Person", dynago.HashKey("Id", 42)).
		UpdateExpression("SET Name=:name").
		Param(":name", "Joe").
		Execute()

	if err != nil {
		fmt.Printf("UpdateItem failed: %v", err)
	}
}
Beispiel #7
0
func TestGet(t *testing.T) {
	assert, client := funcTest.setUp(t)
	putResp, err := client.PutItem("Person", person(42, "Bob")).Execute()
	assert.NoError(err)
	assert.Nil(putResp)

	response, err := client.GetItem("Person", dynago.HashKey("Id", 42)).Execute()
	assert.Equal("Bob", response.Item["Name"])
	assert.IsType(dynago.Number("1"), response.Item["Id"])
	assert.Equal(dynago.Number("42"), response.Item["Id"])
}
func TestMockExecutorGetItem(t *testing.T) {
	assert, client, executor := mockSetup(t)
	client.GetItem("table1", dynago.HashKey("Id", 5)).ConsistentRead(true).Execute()
	assert.Equal(true, executor.GetItemCalled)
	assert.Equal("GetItem", executor.GetItemCall.Method)
	assert.Equal("table1", executor.GetItemCall.Table)
	assert.Equal(true, executor.GetItemCall.ConsistentRead)
	assert.Equal(dynago.Document{"Id": 5}, executor.GetItemCall.Key)
	assert.Equal(1, len(executor.Calls))
	assert.Equal(executor.Calls[0], *executor.GetItemCall)
}
func ExampleClient_BatchWrite(client *dynago.Client) {
	record1 := dynago.Document{"Id": 1, "Name": "Person1"}
	record2 := dynago.Document{"Id": 2, "Name": "Person2"}

	// We can put and delete at the same time to multiple tables.
	client.BatchWrite().
		Put("Table1", record1, record2).
		Put("Table2", dynago.Document{"Name": "Other"}).
		Delete("Table2", dynago.HashKey("Id", 42)).
		Execute()
}
Beispiel #10
0
func TestUpdateItemConditional(t *testing.T) {
	assert, client := funcTest.setUp(t)
	_, err := client.PutItem("Person", person(5, "ToUpdate")).Execute()
	assert.NoError(err)
	result, err := client.UpdateItem("Person", dynago.HashKey("Id", 5)).
		UpdateExpression("SET #n = :name").
		Param("#n", "Name").Param(":name", "Bob").
		ReturnValues(dynago.ReturnUpdatedNew).Execute()
	assert.NoError(err)
	assert.NotNil(result)
	assert.NotNil(result.Attributes)
	assert.Equal("Bob", result.Attributes["Name"])
}
func TestMockExecutorUpdateItem(t *testing.T) {
	assert, client, executor := mockSetup(t)

	client.UpdateItem("table4", dynago.HashKey("Id", 50)).
		UpdateExpression("Foo = :param1").Param(":param1", 90).
		ConditionExpression("#foo > :param2").Param("#foo", "Foo").
		Execute()
	assert.Equal(true, executor.UpdateItemCalled)
	assert.Equal("UpdateItem", executor.UpdateItemCall.Method)
	assert.Equal("table4", executor.UpdateItemCall.Table)
	assert.Equal("Foo = :param1", executor.UpdateItemCall.UpdateExpression)
	assert.Equal("#foo > :param2", executor.UpdateItemCall.ConditionExpression)
	assert.Equal(map[string]string{"#foo": "Foo"}, executor.UpdateItemCall.ExpressionAttributeNames)
	assert.Equal(dynago.Document{":param1": 90}, executor.UpdateItemCall.ExpressionAttributeValues)
}
func TestMockExecutorScan(t *testing.T) {
	assert, client, executor := mockSetup(t)
	scan := client.Scan("table5").
		ExclusiveStartKey(dynago.HashKey("Id", 2)).
		FilterExpression("Foo = :bar", dynago.Param{":bar", 10}).
		ProjectionExpression("Foo, Bar, #baz", dynago.Param{"#baz", "Baz"}).
		IndexName("index5")
	scan.Execute()
	assert.Equal(true, executor.ScanCalled)
	assert.NotNil(executor.ScanCall)
	assert.Equal("Scan", executor.ScanCall.Method)
	assert.Equal("table5", executor.ScanCall.Table)
	assert.Equal("Foo = :bar", executor.ScanCall.FilterExpression)
	assert.Equal(dynago.Document{":bar": 10}, executor.ScanCall.ExpressionAttributeValues)
	assert.Equal(map[string]string{"#baz": "Baz"}, executor.ScanCall.ExpressionAttributeNames)
	assert.Equal("Foo, Bar, #baz", executor.ScanCall.ProjectionExpression)
	assert.Equal("index5", executor.ScanCall.IndexName)
	assert.Nil(executor.ScanCall.Segment)
	scan.Segment(5, 10).Execute()
	assert.Equal(2, len(executor.Calls))
	assert.NotNil(executor.ScanCall.Segment)
	assert.Equal(5, *executor.ScanCall.Segment)
	assert.Equal(10, *executor.ScanCall.TotalSegments)
}