// Create a node structure.
func createNodeStructure(assert audit.Assertion) sml.Node {
builder := sml.NewNodeBuilder()
builder.BeginTagNode("root")
builder.TextNode("Text A")
builder.TextNode("Text B")
builder.CommentNode("A first comment.")
builder.BeginTagNode("sub-a:1st:important")
builder.TextNode("Text A.A")
builder.CommentNode("A second comment.")
builder.EndTagNode()
builder.BeginTagNode("sub-b:2nd")
builder.TextNode("Text B.A")
builder.BeginTagNode("text")
builder.TextNode("Any text with the special characters {, }, and ^.")
builder.EndTagNode()
builder.EndTagNode()
builder.BeginTagNode("sub-c")
builder.TextNode("Before raw.")
builder.RawNode("func Test(i int) { println(i) }")
builder.TextNode("After raw.")
builder.EndTagNode()
builder.EndTagNode()
root, err := builder.Root()
assert.Nil(err)
return root
}
// createConfigurationFile creates a temporary configuration file.
func createConfigurationFile(assert audit.Assertion, content string) (*audit.TempDir, string) {
tempDir := audit.NewTempDir(assert)
configFile, err := ioutil.TempFile(tempDir.String(), "configuration")
assert.Nil(err)
configFileName := configFile.Name()
_, err = configFile.WriteString(content)
assert.Nil(err)
configFile.Close()
return tempDir, configFileName
}
// pipelineDatabase connects to a Redis database with the given options
// and returns a pipeling and a function for closing. This function
// shall be called with a defer.
func pipelineDatabase(assert audit.Assertion, options ...redis.Option) (*redis.Pipeline, func()) {
// Open and connect database.
options = append(options, redis.Index(testDatabaseIndex, ""))
db, err := redis.Open(options...)
assert.Nil(err)
ppl, err := db.Pipeline()
assert.Nil(err)
// Return pipeline and cleanup function.
return ppl, func() {
db.Close()
}
}
// subscribeDatabase connects to a Redis database with the given options
// and returns a subscription and a function for closing. This function
// shall be called with a defer.
func subscribeDatabase(assert audit.Assertion, options ...redis.Option) (*redis.Subscription, func()) {
// Open and connect database.
options = append(options, redis.Index(testDatabaseIndex, ""))
db, err := redis.Open(options...)
assert.Nil(err)
sub, err := db.Subscription()
assert.Nil(err)
// Return subscription and cleanup function.
return sub, func() {
sub.Close()
db.Close()
}
}
// connectDatabase connects to a Redis database with the given options
// and returns a connection and a function for closing. This function
// shall be called with defer.
func connectDatabase(assert audit.Assertion, options ...redis.Option) (*redis.Connection, func()) {
// Open and connect database.
options = append(options, redis.Index(testDatabaseIndex, ""))
db, err := redis.Open(options...)
assert.Nil(err)
conn, err := db.Connection()
assert.Nil(err)
// Flush all keys to get a clean testing environment.
_, err = conn.Do("flushdb")
assert.Nil(err)
// Return connection and cleanup function.
return conn, func() {
conn.Return()
db.Close()
}
}
func createKeyStringValueTree(assert audit.Assertion) collections.KeyStringValueTree {
tree := collections.NewKeyStringValueTree("root", "one", true)
err := tree.At("root").Add("alpha", "two")
assert.Nil(err)
err = tree.At("root").Add("bravo", "three")
assert.Nil(err)
err = tree.At("root", "bravo").Add("foo", "bar")
assert.Nil(err)
err = tree.At("root", "bravo").Add("bar", "foo")
assert.Nil(err)
err = tree.At("root").Add("bravo", "four")
assert.Nil(err)
err = tree.At("root").Add("charlie", "five")
assert.Nil(err)
err = tree.Create("root", "delta", "one").Add("true", "one")
assert.Nil(err)
err = tree.Create("root", "delta", "two").Add("false", "zero")
assert.Nil(err)
assert.Length(tree, 12)
return tree
}
func createTree(assert audit.Assertion) collections.Tree {
tree := collections.NewTree("root", true)
err := tree.At("root").Add("alpha")
assert.Nil(err)
err = tree.At("root").Add("bravo")
assert.Nil(err)
err = tree.At("root", "bravo").Add("foo")
assert.Nil(err)
err = tree.At("root", "bravo").Add("bar")
assert.Nil(err)
err = tree.At("root").Add("bravo")
assert.Nil(err)
err = tree.At("root").Add("charlie")
assert.Nil(err)
err = tree.Create("root", "delta", 1).Add(true)
assert.Nil(err)
err = tree.Create("root", "delta", 2).Add(false)
assert.Nil(err)
assert.Length(tree, 12)
return tree
}
// assertNil checks if the result at index is nil.
func assertNil(assert audit.Assertion, result *redis.ResultSet, index int) {
v, err := result.ValueAt(index)
assert.Nil(err)
assert.Nil(v)
}
// assertEqualInt checks if the result at index is value.
func assertEqualInt(assert audit.Assertion, result *redis.ResultSet, index, value int) {
i, err := result.IntAt(index)
assert.Nil(err)
assert.Equal(i, value)
}
// assertEqualBool checks if the result at index is value.
func assertEqualBool(assert audit.Assertion, result *redis.ResultSet, index int, value bool) {
b, err := result.BoolAt(index)
assert.Nil(err)
assert.Equal(b, value)
}
// assertEqualString checks if the result at index is value.
func assertEqualString(assert audit.Assertion, result *redis.ResultSet, index int, value string) {
s, err := result.StringAt(index)
assert.Nil(err)
assert.Equal(s, value)
}