Пример #1
0
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")
	}

}
Пример #2
0
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")
	}
}
Пример #3
0
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")
	}
}
Пример #4
0
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")
	}

}
Пример #5
0
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)
}
Пример #6
0
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")
	}

}