golang/dep

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package gps

import (
    "testing"

    "github.com/pkg/errors"
)

// just need a listVersions method
type fakeBridge struct {
    *bridge
    vl []Version
}

var fakevl = []Version{
    NewVersion("v2.0.0").Pair("200rev"),
    NewVersion("v1.1.1").Pair("111rev"),
    NewVersion("v1.1.0").Pair("110rev"),
    NewVersion("v1.0.0").Pair("100rev"),
    NewBranch("master").Pair("masterrev"),
}

func init() {
    SortForUpgrade(fakevl)
}

func (fb *fakeBridge) listVersions(id ProjectIdentifier) ([]Version, error) {
    // it's a fixture, we only ever do the one, regardless of id
    return fb.vl, nil
}

type fakeFailBridge struct {
    *bridge
}

var errVQ = errors.New("vqerr")

func (fb *fakeFailBridge) listVersions(id ProjectIdentifier) ([]Version, error) {
    return nil, errVQ
}

func TestVersionQueueSetup(t *testing.T) {
    id := ProjectIdentifier{ProjectRoot: ProjectRoot("foo")}.normalize()

    // shouldn't even need to embed a real bridge
    fb := &fakeBridge{vl: fakevl}
    ffb := &fakeFailBridge{}

    _, err := newVersionQueue(id, nil, nil, ffb)
    if err == nil {
        t.Error("Expected err when providing no prefv or lockv, and injected bridge returns err from ListVersions()")
    }

    vq, err := newVersionQueue(id, nil, nil, fb)
    if err != nil {
        t.Errorf("Unexpected err on vq create: %s", err)
    } else {
        if len(vq.pi) != 5 {
            t.Errorf("Should have five versions from listVersions() when providing no prefv or lockv; got %v:\n\t%s", len(vq.pi), vq.String())
        }
        if !vq.allLoaded {
            t.Errorf("allLoaded flag should be set, but wasn't")
        }

        if vq.prefv != nil || vq.lockv != nil {
            t.Error("lockv and prefv should be nil")
        }
        if vq.current() != fakevl[0] {
            t.Errorf("current should be head of fakevl (%s), got %s", fakevl[0], vq.current())
        }
    }

    lockv := fakevl[0]
    prefv := fakevl[1]
    vq, err = newVersionQueue(id, lockv, nil, fb)
    if err != nil {
        t.Errorf("Unexpected err on vq create: %s", err)
    } else {
        if len(vq.pi) != 1 {
            t.Errorf("Should have one version when providing only a lockv; got %v:\n\t%s", len(vq.pi), vq.String())
        }
        if vq.allLoaded {
            t.Errorf("allLoaded flag should not be set")
        }
        if vq.lockv != lockv {
            t.Errorf("lockv should be %s, was %s", lockv, vq.lockv)
        }
        if vq.current() != lockv {
            t.Errorf("current should be lockv (%s), got %s", lockv, vq.current())
        }
    }

    vq, err = newVersionQueue(id, nil, prefv, fb)
    if err != nil {
        t.Errorf("Unexpected err on vq create: %s", err)
    } else {
        if len(vq.pi) != 1 {
            t.Errorf("Should have one version when providing only a prefv; got %v:\n\t%s", len(vq.pi), vq.String())
        }
        if vq.allLoaded {
            t.Errorf("allLoaded flag should not be set")
        }
        if vq.prefv != prefv {
            t.Errorf("prefv should be %s, was %s", prefv, vq.prefv)
        }
        if vq.current() != prefv {
            t.Errorf("current should be prefv (%s), got %s", prefv, vq.current())
        }
    }

    vq, err = newVersionQueue(id, lockv, prefv, fb)
    if err != nil {
        t.Errorf("Unexpected err on vq create: %s", err)
    } else {
        if len(vq.pi) != 2 {
            t.Errorf("Should have two versions when providing both a prefv and lockv; got %v:\n\t%s", len(vq.pi), vq.String())
        }
        if vq.allLoaded {
            t.Errorf("allLoaded flag should not be set")
        }
        if vq.prefv != prefv {
            t.Errorf("prefv should be %s, was %s", prefv, vq.prefv)
        }
        if vq.lockv != lockv {
            t.Errorf("lockv should be %s, was %s", lockv, vq.lockv)
        }
        if vq.current() != lockv {
            t.Errorf("current should be lockv (%s), got %s", lockv, vq.current())
        }
    }
}

func TestVersionQueueAdvance(t *testing.T) {
    fb := &fakeBridge{vl: fakevl}
    id := ProjectIdentifier{ProjectRoot: ProjectRoot("foo")}.normalize()

    // First with no prefv or lockv
    vq, err := newVersionQueue(id, nil, nil, fb)
    if err != nil {
        t.Fatalf("Unexpected err on vq create: %s", err)
    }

    for k, v := range fakevl[1:] {
        err = vq.advance(errors.Errorf("advancment fail for %s", fakevl[k]))
        if err != nil {
            t.Errorf("error on advancing vq from %s to %s", fakevl[k], v)
            break
        }

        if vq.current() != v {
            t.Errorf("on advance() %v, current should be %s, got %s", k, v, vq.current())
        }
    }

    if vq.isExhausted() {
        t.Error("should not be exhausted until advancing 'past' the end")
    }
    if err = vq.advance(errors.Errorf("final advance failure")); err != nil {
        t.Errorf("should not error on advance, even past end, but got %s", err)
    }

    if !vq.isExhausted() {
        t.Error("advanced past end, should now report exhaustion")
    }
    if vq.current() != nil {
        t.Error("advanced past end, current should return nil")
    }

    // now, do one with both a prefv and lockv
    lockv := fakevl[2]
    prefv := fakevl[0]
    vq, err = newVersionQueue(id, lockv, prefv, fb)
    if err != nil {
        t.Errorf("error creating version queue: %v", err)
    }
    if vq.String() != "[v1.1.0, v2.0.0]" {
        t.Error("stringifying vq did not have expected outcome, got", vq.String())
    }
    if vq.isExhausted() {
        t.Error("can't be exhausted, we aren't even 'allLoaded' yet")
    }

    err = vq.advance(errors.Errorf("dequeue lockv"))
    if err != nil {
        t.Error("unexpected error when advancing past lockv", err)
    } else {
        if vq.current() != prefv {
            t.Errorf("current should be prefv (%s) after first advance, got %s", prefv, vq.current())
        }
        if len(vq.pi) != 1 {
            t.Errorf("should have just prefv elem left in vq, but there are %v:\n\t%s", len(vq.pi), vq.String())
        }
    }

    err = vq.advance(errors.Errorf("dequeue prefv"))
    if err != nil {
        t.Error("unexpected error when advancing past prefv", err)
    } else {
        if !vq.allLoaded {
            t.Error("allLoaded should now be true")
        }
        if len(vq.pi) != 3 {
            t.Errorf("should have three remaining versions after removing prefv and lockv, but there are %v:\n\t%s", len(vq.pi), vq.String())
        }
        if vq.current() != fakevl[1] {
            t.Errorf("current should be first elem of fakevl (%s) after advancing into all, got %s", fakevl[1], vq.current())
        }
    }

    // make sure the queue ordering is still right even with a double-delete
    vq.advance(nil)
    if vq.current() != fakevl[3] {
        t.Errorf("second elem after ListVersions() should be idx 3 of fakevl (%s), got %s", fakevl[3], vq.current())
    }
    vq.advance(nil)
    if vq.current() != fakevl[4] {
        t.Errorf("third elem after ListVersions() should be idx 4 of fakevl (%s), got %s", fakevl[4], vq.current())
    }
    vq.advance(nil)
    if vq.current() != nil || !vq.isExhausted() {
        t.Error("should be out of versions in the queue")
    }

    // Make sure we handle things correctly when listVersions adds nothing new
    fb = &fakeBridge{vl: []Version{lockv, prefv}}
    vq, err = newVersionQueue(id, lockv, prefv, fb)
    if err != nil {
        t.Errorf("error creating version queue: %v", err)
    }
    vq.advance(nil)
    vq.advance(nil)
    if vq.current() != nil || !vq.isExhausted() {
        t.Errorf("should have no versions left, as ListVersions() added nothing new, but still have %s", vq.String())
    }
    err = vq.advance(nil)
    if err != nil {
        t.Errorf("should be fine to advance on empty queue, per docs, but got err %s", err)
    }

    // Also handle it well when advancing calls ListVersions() and it gets an
    // error
    vq, err = newVersionQueue(id, lockv, nil, &fakeFailBridge{})
    if err != nil {
        t.Errorf("should not err on creation when preseeded with lockv, but got err %s", err)
    }
    err = vq.advance(nil)
    if err == nil {
        t.Error("advancing should trigger call to erroring bridge, but no err")
    }
    err = vq.advance(nil)
    if err == nil {
        t.Error("err should be stored for reuse on any subsequent calls")
    }

}