func TestDefaultLookupChecker(t *testing.T) {
dlu := storage.DefaultLookup
c := newChecker(dlu)
ip, tp := predicate.NewImmutable("foo"), predicate.NewTemporal("bar", time.Now())
if !c.CheckAndUpdate(ip) {
t.Errorf("Immutable predicates should always validate with default lookup %v", dlu)
}
if !c.CheckAndUpdate(tp) {
t.Errorf("Temporal predicates should always validate with default lookup %v", dlu)
}
}
// Reify given the current triple it returns the original triple and the newly
// reified ones. It also returns the newly created blank node.
func (t *Triple) Reify() ([]*Triple, *node.Node, error) {
// Function that create the proper reification predicates.
rp := func(id string, p *predicate.Predicate) (*predicate.Predicate, error) {
if p.Type() == predicate.Temporal {
ta, _ := p.TimeAnchor()
return predicate.NewTemporal(string(p.ID()), *ta)
}
return predicate.NewImmutable(id)
}
fmt.Println(t.String())
b := node.NewBlankNode()
s, err := rp("_subject", t.p)
if err != nil {
return nil, nil, err
}
ts, _ := NewTriple(b, s, NewNodeObject(t.s))
p, err := rp("_predicate", t.p)
if err != nil {
return nil, nil, err
}
tp, _ := NewTriple(b, p, NewPredicateObject(t.p))
var to *Triple
if t.o.l != nil {
o, err := rp("_object", t.p)
if err != nil {
return nil, nil, err
}
to, _ = NewTriple(b, o, NewLiteralObject(t.o.l))
}
if t.o.n != nil {
o, err := rp("_object", t.p)
if err != nil {
return nil, nil, err
}
to, _ = NewTriple(b, o, NewNodeObject(t.o.n))
}
if t.o.p != nil {
o, err := rp("_object", t.p)
if err != nil {
return nil, nil, err
}
to, _ = NewTriple(b, o, NewPredicateObject(t.o.p))
}
return []*Triple{t, ts, tp, to}, b, nil
}
