//ReadTags reads tags of Peer p.
func (p *Peer) ReadTags() (tag.Tags, error) {
var ts TagsProto
if err := p.readDAG(config.TagsPath, &ts); log.If(err) {
return nil, err
}
tags := make(tag.Tags)
for _, t := range ts.T {
tag := tag.New(*t.Thread)
tag.AddSlice(t.GetTag())
tags.Add(tag)
}
return tags, nil
}
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")
}
}
