//AddRecord adds a record and returns true if updated.
func (m *Manager) AddRecord(thread string, stamp time.Time, contents map[string][]byte, sign bool) (bool, error) {
r, err := record.New(m.self, thread, stamp, contents, sign)
if log.If(err) {
return false, err
}
m.mutex.Lock()
defer m.mutex.Unlock()
return m.recent.Add(r)
}
func TestThread(t *testing.T) {
const (
rootPath = "test"
)
jsonstr := `
{
"max_connection":12,
"file_dir":".",
"run_dir":"rundir",
"option":"option"
}
`
if err := ioutil.WriteFile("test.json", []byte(jsonstr), 0644); err != nil {
t.Error(err)
}
var cfg config.Config
config.Load(rootPath, ".", &cfg)
cfg.SetDefaults()
self := peer.NewSelf(&cfg, rootPath)
log.Println("start")
cont := map[string][]byte{
"test1": []byte("data1"),
"test2": []byte("data2"),
}
r1, err := record.New(self, "testA", time.Now(), cont, true)
if err != nil {
t.Fatal(err)
}
cont2 := map[string][]byte{
"test3": []byte("data1"),
"test4": []byte("data2"),
}
r2, err := record.New(self, "testA", time.Now().Add(-time.Hour), cont2, true)
if err != nil {
t.Fatal(err)
}
cont3 := map[string][]byte{
"test5": []byte("data1"),
"test6": []byte("data2"),
}
r3, err := record.New(self, "testA", time.Now(), cont3, true)
if err != nil {
t.Fatal(err)
}
th, err := New(self, "testA", "")
if err != nil {
t.Fatal(err)
}
if _, err = th.Add(r1); err != nil {
t.Fatal(err)
}
recs1, err := th.Slice(0, 3, nil)
log.Println("1 length", len(recs1))
if _, err = th.Add(r2); err != nil {
t.Fatal(err)
}
recs2, err := th.Slice(0, 3, nil)
log.Println("2 length", len(recs2))
if _, err = th.Add(r3); err != nil {
t.Fatal(err)
}
recs, err := th.Slice(0, 3, nil)
if err != nil {
t.Fatal(err)
}
if len(recs) != 3 {
t.Fatal("illegal slice length", len(recs))
}
if !recs[0].Equals(r3) {
t.Fatal("illegal slice")
}
if !recs[1].Equals(r1) {
t.Fatal("illegal slice")
}
if !recs[2].Equals(r2) {
t.Fatal("illegal slice")
}
cont4 := map[string][]byte{
"test7": []byte("data1"),
"test8": []byte("data2"),
}
r4, err := record.New(self, "testA", time.Now(), cont4, true)
th2, err := New(self, "testA", "")
if err != nil {
t.Fatal(err)
}
updated, err := th2.Add(r1)
if err != nil {
t.Fatal(err)
}
if !updated {
t.Fatal("illegal updated flag")
}
if _, err = th2.Add(r4); err != nil {
t.Fatal(err)
}
if _, err = th2.Add(r3); err != nil {
t.Fatal(err)
}
updated, err = th.Merge(th2.Key())
if err != nil {
t.Fatal(err)
}
if !updated {
t.Fatal("illegal updated flag")
}
recs, err = th.Slice(0, 4, nil)
if err != nil {
t.Fatal(err)
}
if len(recs) != 4 {
t.Fatal("illegal slice length", len(recs))
}
if !recs[0].Equals(r4) {
t.Fatal("illegal slice")
}
if !recs[1].Equals(r3) {
t.Fatal("illegal slice")
}
if !recs[2].Equals(r1) {
t.Fatal("illegal slice")
}
if !recs[3].Equals(r2) {
t.Fatal("illegal slice")
}
}
func TestThreadList(t *testing.T) {
const (
rootPath = "test"
)
jsonstr := `
{
"max_connection":12,
"file_dir":".",
"run_dir":"rundir",
"option":"option"
}
`
if err := ioutil.WriteFile("test.json", []byte(jsonstr), 0644); err != nil {
t.Error(err)
}
var cfg config.Config
config.Load(rootPath, ".", &cfg)
cfg.SetDefaults()
self := peer.NewSelf(&cfg, rootPath)
log.Println("start")
cont := map[string][]byte{
"test1": []byte("data1"),
"test2": []byte("data2"),
}
r1, err := record.New(self, "testA", time.Now(), cont, true)
if err != nil {
t.Fatal(err)
}
cont2 := map[string][]byte{
"test3": []byte("data1"),
"test4": []byte("data2"),
}
r2, err := record.New(self, "testB", time.Now(), cont2, true)
if err != nil {
t.Fatal(err)
}
cont3 := map[string][]byte{
"test5": []byte("data1"),
"test6": []byte("data2"),
}
r3, err := record.New(self, "testC", time.Now(), cont3, true)
cont4 := map[string][]byte{
"test7": []byte("data1"),
"test8": []byte("data2"),
}
nowt := time.Now()
r4, err := record.New(self, "testB", nowt, cont4, true)
if err != nil {
t.Fatal(err)
}
tl, err := NewList(self, "")
if err != nil {
t.Fatal(err)
}
if _, err = tl.Add(r1); err != nil {
t.Fatal(err)
}
if _, err = tl.Add(r2); err != nil {
t.Fatal(err)
}
if _, err = tl.Add(r3); err != nil {
t.Fatal(err)
}
if _, err = tl.Add(r4); err != nil {
t.Fatal(err)
}
th, err := tl.GetThread("testB")
if err != nil {
t.Fatal(err)
}
sl, err := th.Slice(0, 10, nil)
if len(sl) != 2 {
t.Fatal("illegal slice")
}
re, err := tl.Recent()
if err != nil {
t.Fatal(err)
}
if len(re) != 3 {
t.Fatal("illegal recent")
}
if re[0].Thread != "testB" || !re[0].Stamp.Equal(nowt) {
t.Fatal("illegal recent")
}
if re[1].Thread != "testC" {
t.Fatal("illegal recent")
}
if re[2].Thread != "testA" {
t.Fatal("illegal recent")
}
tl2, err := NewList(self, "")
if err != nil {
t.Fatal(err)
}
if _, err = tl2.Add(r1); err != nil {
t.Fatal(err)
}
if _, err = tl2.Add(r3); err != nil {
t.Fatal(err)
}
if _, err = tl2.Add(r4); err != nil {
t.Fatal(err)
}
cont5 := map[string][]byte{
"test9": []byte("data1"),
"test10": []byte("data2"),
}
r5, err := record.New(self, "testD", time.Now(), cont5, true)
if _, err = tl2.Add(r5); err != nil {
t.Fatal(err)
}
updated, err := tl.Merge(tl2.Key())
if err != nil {
t.Fatal(err)
}
if !updated {
t.Fatal("illegal update flag")
}
re, err = tl.Recent()
if err != nil {
t.Fatal(err)
}
if len(re) != 4 {
t.Fatal("illegal recent", len(re))
}
if re[0].Thread != "testD" {
t.Fatal("illegal recent")
}
if re[1].Thread != "testB" {
t.Fatal("illegal recent")
}
if re[2].Thread != "testC" {
t.Fatal("illegal recent")
}
if re[3].Thread != "testA" {
t.Fatal("illegal recent")
}
}