func TestRecord(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)
cont := map[string][]byte{
"test1": []byte("data1"),
"test2": []byte("data2"),
}
r, err := New(self, "test", time.Now(), cont, true)
if err != nil {
t.Fatal(err)
}
s, err := r.Signer()
if err != nil {
t.Fatal(err)
}
if s != self.NodeName() {
t.Fatal("illegal singer")
}
dag, err := r.ToDAGNode()
if err != nil {
t.Fatal(err)
}
r2, err := FromDAGNode(self, dag, r.Sign)
if err != nil {
t.Fatal(err)
}
if !r.Equals(r2) {
t.Fatal("illegal equals")
}
}
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 TestPeer(t *testing.T) {
const (
rootPath = "test"
)
jsonstr := `
{
"max_connection":12,
"file_dir":".",
"run_dir":"rundir",
"option":"option"
}
`
denied := `
QmZQJubLBGn1JUv8zx24TasR57LnyK1KjUiHWncVqrPxy7
QmU3eUhmUnZxtUJzMtq8YNVz2Q1U75fn2DEgoMXWcCNf6v
QmPhL4RCK1h241eyMBbYxPBv4iBuguPbRB2gGbGjsuXLQv
QmUt5G1QiJePEGKQvjZwcjisoUNUfmKZaATXQcDYJsoEEj
`
if err := ioutil.WriteFile("denied_peers.txt", []byte(denied), 0644); err != nil {
t.Error(err)
}
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 := NewSelf(&cfg, rootPath)
m := self.ToPeer()
skeys := []string{
"QmZQJubLBGn1JUv8zx24TasR57LnyK1KjUiHWncVqrPxy7",
"QmU3eUhmUnZxtUJzMtq8YNVz2Q1U75fn2DEgoMXWcCNf6v",
"QmdrPVCaguLLJM2QnK5qdBDqYwQWQKuq4yHK8E9zX1Et8X",
"QmPhL4RCK1h241eyMBbYxPBv4iBuguPbRB2gGbGjsuXLQv",
}
k := key.B58KeyDecode(skeys[0])
p, err := FromBytes([]byte(k), self)
if err != nil {
t.Fatal(err)
}
if skeys[0] != p.String() {
t.Fatal("cannot new")
}
if m.Equals(p) {
t.Fatal("illegal equals")
}
b, err := crypto.MarshalPublicKey(self.Pubkey())
if err != nil {
t.Fatal(err)
}
p, err = FromPubkey(b, self)
if err != nil {
t.Fatal(err)
}
if self.NodeName().Pretty() != p.String() {
t.Fatal("cannot new")
}
if !m.Equals(p) {
t.Fatal("illegal equals")
}
p, err = New(skeys[0], self)
if err != nil {
t.Fatal(err)
}
if skeys[0] != p.String() {
t.Fatal("cannot new")
}
if p.IsAllowed() {
t.Fatal("illegally allowed")
}
p, err = New(skeys[2], self)
if err != nil {
t.Fatal(err)
}
if !p.IsAllowed() {
t.Fatal("illegally denied")
}
ps := FromStringSlice(skeys, self)
strs := ps.Strings()
if len(strs) != len(ps) {
t.Fatal("illegally strings")
}
for _, s := range strs {
ok := false
for _, s2 := range skeys {
if s == s2 {
ok = true
}
}
if !ok {
t.Fatal("illegally strings")
}
}
sl := ps.Slice()
ps2 := FromSlice(sl)
if !ps.Equals(ps2) {
t.Fatal("illegal slicing")
}
if len(sl) != len(skeys) {
t.Fatal("illegal slicing")
}
ps3 := FromStringSlice(skeys[1:], self)
ps4 := ps.Excludes(ps3, 0)
if len(ps4) != 1 {
t.Fatal("illegal excludes")
}
ps5 := FromStringSlice(skeys[3:], self)
ps6 := ps.Excludes(ps5, 2)
if len(ps6) != 2 {
t.Fatal("illegal excludes")
}
ps7 := FromStringSlice(skeys[1:], self)
ps8 := FromStringSlice(skeys[:2], self)
ps8.Extend(ps7)
if !ps.Equals(ps8) {
t.Fatal("illegal extends")
}
}
func TestSelf(t *testing.T) {
const (
rootPath = "test"
)
jsonstr := `
{
"max_connection":12,
"file_dir":".",
"run_dir":".",
"option":"option"
}
`
if err := fsrepo.Remove("./.ipfs/"); err != nil {
log.Println(err)
}
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 := NewSelf(&cfg, rootPath)
log.Println("node name", self.NodeName().Pretty())
if self.NodeName() == "" {
t.Fatal("nodename is empty")
}
n := &merkledag.Node{}
n.Data = []byte("root")
n1 := &merkledag.Node{}
n1.Data = []byte("leaf")
if err := n.AddNodeLink("leaf", n1); err != nil {
t.Fatal(err)
}
k, err := self.AddDAGNode(n, false)
if err != nil {
t.Fatal(err)
}
nn, err := self.GetDAGNode(k)
if err != nil {
t.Fatal(err)
}
log.Println(string(nn.Data))
if string(n.Data) != string(nn.Data) {
t.Fatal("not match merkle data")
}
d := []byte("test")
pub := self.Pubkey()
s, err := self.Sign(d)
if err != nil {
t.Fatal(err)
}
ok, err := pub.Verify(d, s)
if err != nil {
t.Fatal(err)
}
if !ok {
t.Fatal("cannot verify")
}
ok, err = pub.Verify(d, []byte("aa"))
if err == nil && ok {
t.Fatal("invalid verify")
}
skeys := []string{
"QmZQJubLBGn1JUv8zx24TasR57LnyK1KjUiHWncVqrPxy7",
"QmU3eUhmUnZxtUJzMtq8YNVz2Q1U75fn2DEgoMXWcCNf6v",
"QmdrPVCaguLLJM2QnK5qdBDqYwQWQKuq4yHK8E9zX1Et8X",
"QmPhL4RCK1h241eyMBbYxPBv4iBuguPbRB2gGbGjsuXLQv",
}
keys := slice.FromB58Slice(skeys)
peers := FromStringSlice(skeys, self)
st, err := self.StorageUsage()
if err != nil {
t.Fatal(err)
}
log.Println("storage usage", st, "bytes")
if st <= 0 {
t.Fatal("illegal storage usage")
}
peers1 := FromStringSlice(skeys[1:], self)
peers2 := FromStringSlice(skeys[:2], self)
wpd, err := self.WritePeersToDAG(peers, key.Key(""))
if err != nil {
t.Fatal(err)
}
wpd, err = self.WritePeersToDAG(peers1, wpd)
if err != nil {
t.Fatal(err)
}
wpd, err = self.WritePeersToDAG(peers2, wpd)
if err != nil {
t.Fatal(err)
}
p0, k0, err := self.ReadPeersFromDAG(wpd)
if err != nil {
t.Fatal(err)
}
if !peers2.Equals(p0) {
t.Fatal("cannot write/read peer list", len(p0))
}
p1, k1, err := self.ReadPeersFromDAG(k0)
if err != nil {
t.Fatal(err)
}
if !peers1.Equals(p1) {
t.Fatal("cannot write/read peer list")
}
p2, k2, err := self.ReadPeersFromDAG(k1)
if err != nil {
t.Fatal(err)
}
if !peers.Equals(p2) {
t.Fatal("cannot write/read peer list")
}
if k2 != "" {
t.Fatal("illegal link")
}
ts := make(slice.String)
ts.Add("a")
ts.Add("b")
ts.Add("c")
self.WriteThread(ts)
if err := self.WriteSpams(keys); err != nil {
t.Fatal(err)
}
if err := self.WritePeers(peers); err != nil {
t.Fatal(err)
}
if err := self.WriteRecent(key.B58KeyDecode(skeys[0])); err != nil {
t.Fatal(err)
}
tag1 := tag.New("test1")
tagstr := []string{
"rec1",
"rec3",
"rec4",
}
tag1.AddSlice(tagstr)
tag2 := tag.New("test1")
if !tag2.Add("rec1") {
t.Errorf("illegal adds")
}
tag3 := tag.New("test2")
if !tag3.Add("rec1") {
t.Errorf("illegal adds")
}
tags := make(tag.Tags)
tags.Add(tag1)
tags.Add(tag2)
tags.Add(tag3)
if err := self.WriteTag(tags); err != nil {
t.Fatal(err)
}
log.Println("waiting for namesys cache will be outdated.")
time.Sleep(time.Minute)
myp := self.ToPeer()
nnn, err := myp.GetDAGNode("")
if err != nil {
t.Fatal(err)
}
knnn, err := nnn.Key()
if err != nil {
t.Fatal(err)
}
if knnn != self.myIpns {
t.Fatal("illegal ipns key")
}
thh := self.ReadThreads()
if !thh.Equals(ts) {
t.Error("failed to read threads", len(thh))
}
spam, err := myp.ReadSpams()
if err != nil {
t.Fatal(err)
}
if !spam.Equals(keys) {
t.Error("failed to read spam", len(spam))
}
r, err := myp.ReadRecent()
if err != nil {
t.Fatal(err)
}
if r != key.B58KeyDecode(skeys[0]) {
t.Error("cannot read recent")
}
rpeers, err := myp.ReadPeers()
if err != nil {
t.Fatal(err)
}
if !rpeers.Equals(peers) {
t.Error("failed to read peers")
}
rtag, err := myp.ReadTags()
if err != nil {
t.Fatal(err)
}
if !rtag.Equals(tags) {
t.Error("failed to read peers")
}
}
func TestManager(t *testing.T) {
const (
rootPath = "test"
)
jsonstr := `
{
"ipfs_repo":"./test1/.ipfs",
"file_dir":"./test1",
"run_dir":"./test1"
}
`
jsonstr2 := `
{
"ipfs_repo":"./test2/.ipfs",
"file_dir":"./test2",
"run_dir":"./test2"
}
`
if err := os.RemoveAll("./test1"); err != nil {
t.Log(err)
}
if err := os.RemoveAll("./test2"); err != nil {
t.Log(err)
}
if err := os.Mkdir("./test1", 0755); err != nil {
t.Fatal(err)
}
if err := os.Mkdir("./test2", 0755); err != nil {
t.Fatal(err)
}
if err := fsrepo.Remove("./.ipfs"); err != nil {
log.Println(err)
}
if err := ioutil.WriteFile("test.json", []byte(jsonstr), 0644); err != nil {
t.Error(err)
}
var cfg config.Config
config.Load(rootPath, ".", &cfg)
cfg.SetDefaults()
mng, err := New(&cfg, rootPath)
if err != nil {
t.Fatal(err)
}
if err := ioutil.WriteFile("./test2/init_peers.txt",
[]byte(mng.NodeName().Pretty()), 0644); err != nil {
t.Error(err)
}
if err := fsrepo.Remove("./.ipfs2"); err != nil {
log.Println(err)
}
if err := ioutil.WriteFile("test.json", []byte(jsonstr2), 0644); err != nil {
t.Error(err)
}
var cfg2 config.Config
config.Load(rootPath, ".", &cfg2)
cfg2.SetDefaults()
mng2, err := New(&cfg2, rootPath)
if err != nil {
t.Fatal(err)
}
if len(mng2.peers) != 1 {
t.Fatal("illegal peers")
}
cont1 := map[string][]byte{
"test1": []byte("data1"),
"test2": []byte("data2"),
}
cont2 := map[string][]byte{
"test3": []byte("data1"),
"test4": []byte("data2"),
}
updated, err := mng2.AddRecord("testA", time.Now(), cont1, true)
if err != nil {
t.Fatal(err)
}
if !updated {
t.Fatal("illegal update flag")
}
updated, err = mng2.AddRecord("testA", time.Now(), cont2, true)
if err != nil {
t.Fatal(err)
}
if !updated {
t.Fatal("illegal update flag")
}
if err := mng2.Broadcast(); err != nil {
t.Fatal(err)
}
time.Sleep(time.Minute)
log.Println(mng, mng2)
}
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")
}
}