389 lines
8.7 KiB
Go
389 lines
8.7 KiB
Go
package storage
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"local/dndex/storage/entity"
|
|
"local/dndex/storage/operator"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
func TestIntegration(t *testing.T) {
|
|
os.Args = os.Args[:1]
|
|
f, err := ioutil.TempFile(os.TempDir(), "pattern*")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
f.Close()
|
|
defer os.Remove(f.Name())
|
|
os.Setenv("DBURI", f.Name())
|
|
graph := NewRateLimitedGraph()
|
|
ctx, can := context.WithCancel(context.TODO())
|
|
defer can()
|
|
clean := func() {
|
|
graph.g.driver.Delete(context.TODO(), "col", map[string]string{})
|
|
}
|
|
clean()
|
|
defer clean()
|
|
|
|
ones := []entity.One{
|
|
randomOne(),
|
|
randomOne(),
|
|
randomOne(),
|
|
}
|
|
ones[0].Connections = map[string]entity.One{ones[2].Name: entity.One{Name: ones[2].Name, Relationship: ":("}}
|
|
ones[1].Name = ones[0].Name[1 : len(ones[0].Name)-1]
|
|
cleanFill := func() {
|
|
clean()
|
|
for i := range ones {
|
|
if err := graph.g.driver.Insert(context.TODO(), "col", ones[i]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
t.Run("graph.Insert(...)", func(t *testing.T) {
|
|
clean()
|
|
for _, one := range ones {
|
|
err := graph.Insert(ctx, "col", one)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("graph.List", func(t *testing.T) {
|
|
cleanFill()
|
|
all, err := graph.List(ctx, "col")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Logf("\nall = %+v", all)
|
|
if len(all) != 3 {
|
|
t.Fatalf("%v: %+v", len(all), all)
|
|
}
|
|
})
|
|
|
|
t.Run("graph.ListCaseInsensitive", func(t *testing.T) {
|
|
cleanFill()
|
|
all, err := graph.ListCaseInsensitive(ctx, "col")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Logf("\nall = %+v", all)
|
|
if len(all) != 3 {
|
|
t.Fatalf("%v: %+v", len(all), all)
|
|
}
|
|
})
|
|
|
|
t.Run("graph.List(foo => *)", func(t *testing.T) {
|
|
cleanFill()
|
|
some, err := graph.List(ctx, "col", ones[0].Peers()...)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Logf("\nsom = %+v", some)
|
|
if len(some) != 1 {
|
|
t.Fatalf("%+v: %+v", len(some), some)
|
|
}
|
|
})
|
|
|
|
t.Run("graph.List(FOO => *)", func(t *testing.T) {
|
|
cleanFill()
|
|
peers := ones[0].Peers()
|
|
for i := range peers {
|
|
peers[i] = strings.ToUpper(peers[i])
|
|
}
|
|
some, err := graph.List(ctx, "col", peers...)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Logf("\nsom = %+v", some)
|
|
if len(some) != 0 {
|
|
t.Fatalf("%+v: %+v", len(some), some)
|
|
}
|
|
})
|
|
|
|
t.Run("graph.ListCaseInsensitive(FOO => *)", func(t *testing.T) {
|
|
cleanFill()
|
|
peers := ones[0].Peers()
|
|
for i := range peers {
|
|
peers[i] = strings.ToUpper(peers[i])
|
|
}
|
|
some, err := graph.ListCaseInsensitive(ctx, "col", peers...)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Logf("\nsom = %+v", some)
|
|
if len(some) != 1 {
|
|
t.Fatalf("%+v: %+v", len(some), some)
|
|
}
|
|
})
|
|
|
|
t.Run("graph.Delete(case insensitives() => 0)", func(t *testing.T) {
|
|
cleanFill()
|
|
err := graph.Delete(ctx, "col", operator.CaseInsensitives{Key: entity.Name, Values: []string{}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ones, err := graph.List(ctx, "col")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(ones) != 0 {
|
|
t.Fatal(len(ones))
|
|
}
|
|
})
|
|
|
|
t.Run("graph.Delete(case insensitives(.*) => 0)", func(t *testing.T) {
|
|
cleanFill()
|
|
err := graph.Delete(ctx, "col", operator.CaseInsensitives{Key: entity.Name, Values: []string{".*"}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ones, err := graph.List(ctx, "col")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(ones) < 0 {
|
|
t.Fatal(len(ones))
|
|
}
|
|
})
|
|
|
|
t.Run("graph.Delete(case insensitive(.*) => 0)", func(t *testing.T) {
|
|
cleanFill()
|
|
err := graph.Delete(ctx, "col", operator.CaseInsensitive{Key: entity.Name, Value: ".*"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ones, err := graph.List(ctx, "col")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(ones) < 0 {
|
|
t.Fatal(len(ones))
|
|
}
|
|
})
|
|
|
|
t.Run("graph.Search(foo => *)", func(t *testing.T) {
|
|
cleanFill()
|
|
some, err := graph.Search(ctx, "col", ones[0].Name[:3])
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Logf("searching for %s (%s)\nsom = %+v", ones[0].Name, ones[0].Name[:3], some)
|
|
if len(some) < 1 {
|
|
t.Fatalf("%+v: %+v", len(some), some)
|
|
}
|
|
})
|
|
|
|
t.Run("graph.Update(foo, --bar)", func(t *testing.T) {
|
|
cleanFill()
|
|
err := graph.Update(ctx, "col", ones[0].Query(), operator.Set{entity.Connections, map[string]interface{}{}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
some, err := graph.List(ctx, "col", ones[0].Name)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Logf("\nsm' = %+v", some)
|
|
|
|
if len(some) != 1 {
|
|
t.Fatal(len(some))
|
|
}
|
|
if some[0].Name != ones[0].Name {
|
|
t.Fatal(some[0].Name)
|
|
}
|
|
if l := len(some[0].Peers()); l > 0 {
|
|
t.Fatalf("%d: %+v", l, some[0])
|
|
}
|
|
})
|
|
|
|
t.Run("graph.Update(foo, +=2); graph.Update(foo, -=1)", func(t *testing.T) {
|
|
cleanFill()
|
|
err := graph.Update(ctx, "col", ones[0].Query(), operator.Set{entity.Connections, map[string]entity.One{
|
|
"hello": entity.One{Name: "hello", Relationship: ":("},
|
|
"world": entity.One{Name: "world", Relationship: ":("},
|
|
}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
some1, err := graph.List(ctx, "col", ones[0].Name)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Logf("sm1 = %+v", some1[0])
|
|
if len(some1) != 1 {
|
|
t.Fatal(len(some1))
|
|
}
|
|
if len(some1[0].Peers()) != 2 {
|
|
t.Fatal(some1[0].Peers())
|
|
}
|
|
|
|
err = graph.Update(ctx, "col", ones[0].Query(), operator.Unset(fmt.Sprintf("%s.world", entity.Connections)))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
some2, err := graph.List(ctx, "col", ones[0].Name)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Logf("sm2 = %+v", some2[0])
|
|
if len(some2) != 1 {
|
|
t.Fatal(len(some2))
|
|
}
|
|
if len(some2[0].Peers()) != 1 {
|
|
t.Fatal(some2[0].Peers())
|
|
}
|
|
})
|
|
|
|
t.Run("graph.Update(new attachment), Update(--new attachment)", func(t *testing.T) {
|
|
cleanFill()
|
|
err := graph.Update(ctx, "col", ones[0].Query(), operator.Set{Key: fmt.Sprintf("%s.new attachment", entity.Attachments), Value: "my new attachment"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
some1, err := graph.List(ctx, "col", ones[0].Name)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Logf("sm1 = %+v", some1[0])
|
|
if len(some1) != 1 {
|
|
t.Fatal(len(some1))
|
|
}
|
|
if v, ok := some1[0].Attachments["new attachment"]; !ok {
|
|
t.Fatal(ok, some1[0].Attachments)
|
|
} else if v != "my new attachment" {
|
|
t.Fatal(v, some1[0].Attachments)
|
|
}
|
|
|
|
err = graph.Update(ctx, "col", ones[0].Query(), operator.Unset(fmt.Sprintf("%s.new attachment", entity.Attachments)))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
some2, err := graph.List(ctx, "col", ones[0].Name)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Logf("sm1 = %+v", some2[0])
|
|
if len(some2) != 1 {
|
|
t.Fatal(len(some2))
|
|
}
|
|
if _, ok := some2[0].Attachments["new attachment"]; ok {
|
|
t.Fatal(ok, some2[0].Attachments)
|
|
} else if len(some2[0].Attachments) == 0 {
|
|
t.Fatal(len(some2[0].Attachments), some2[0].Attachments)
|
|
}
|
|
})
|
|
|
|
t.Run("graph.Insert Collision(...)", func(t *testing.T) {
|
|
cleanFill()
|
|
one := randomOne()
|
|
err := graph.Insert(ctx, "col", one)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
one.Name = strings.ToUpper(one.Name)
|
|
err = graph.Insert(ctx, "col", one)
|
|
if err == nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = graph.Delete(ctx, "col", operator.CaseInsensitive{Key: entity.Name, Value: one.Name})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
ones, err = graph.ListCaseInsensitive(ctx, "col", one.Name)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(ones) > 0 {
|
|
t.Fatal(err)
|
|
}
|
|
})
|
|
|
|
t.Run("graph.Insert Collision(...)", func(t *testing.T) {
|
|
cleanFill()
|
|
one := randomOne()
|
|
err := graph.Insert(ctx, "col", one)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = graph.Insert(ctx, "col", one)
|
|
if err == nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = graph.Delete(ctx, "col", operator.CaseInsensitive{Key: entity.Name, Value: one.Name})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
ones, err = graph.ListCaseInsensitive(ctx, "col", one.Name)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(ones) > 0 {
|
|
t.Fatal(err)
|
|
}
|
|
})
|
|
|
|
t.Run("graph.Update connections when none previously", func(t *testing.T) {
|
|
cleanFill()
|
|
one := randomOne()
|
|
one.Connections = nil
|
|
err := graph.Insert(ctx, "col", one)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = graph.Update(ctx, "col", one.Query(), operator.Set{Key: entity.Connections + ".newfriend", Value: randomOne()})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
ones, err = graph.ListCaseInsensitive(ctx, "col", one.Name)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(ones) != 1 {
|
|
t.Fatal(ones)
|
|
}
|
|
if len(ones[0].Connections) != 1 {
|
|
t.Fatal(ones[0].Connections)
|
|
}
|
|
if _, ok := ones[0].Connections["newfriend"]; !ok {
|
|
t.Fatal(ones[0].Connections)
|
|
}
|
|
})
|
|
}
|
|
|
|
func randomOne() entity.One {
|
|
return entity.One{
|
|
Name: "name-" + uuid.New().String()[:5],
|
|
Type: "Humman",
|
|
Title: "Biggus",
|
|
Text: "tee hee xd",
|
|
Modified: time.Now().UnixNano(),
|
|
Connections: map[string]entity.One{},
|
|
Attachments: map[string]string{
|
|
"pdf file": "/path/to.pdf",
|
|
"png file": "/path/to.png",
|
|
},
|
|
}
|
|
}
|