func TestControllerError(t *testing.T) {
testCases := map[string]struct {
err func() error
errFn func(err error) bool
reactFn testclient.ReactionFunc
actions int
}{
"not found": {
err: func() error { return errors.NewNotFound("namespace", "test") },
errFn: func(err error) bool { return err == nil },
actions: 1,
},
"unknown": {
err: func() error { return fmt.Errorf("unknown") },
errFn: func(err error) bool { return err.Error() == "unknown" },
actions: 1,
},
"conflict": {
actions: 4,
reactFn: func(a testclient.FakeAction) (runtime.Object, error) {
if a.Action == "get-namespace" {
return &kapi.Namespace{ObjectMeta: kapi.ObjectMeta{Name: "test"}}, nil
}
return (*kapi.Namespace)(nil), errors.NewConflict("namespace", "test", fmt.Errorf("test conflict"))
},
errFn: func(err error) bool {
return err != nil && strings.Contains(err.Error(), "unable to allocate security info")
},
},
}
for s, testCase := range testCases {
client := &testclient.Fake{ReactFn: testCase.reactFn}
if client.ReactFn == nil {
client.ReactFn = func(a testclient.FakeAction) (runtime.Object, error) {
return (*kapi.Namespace)(nil), testCase.err()
}
}
uidr, _ := uid.NewRange(10, 19, 2)
mcsr, _ := mcs.NewRange("s0:", 10, 2)
uida := uidallocator.NewInMemory(uidr)
c := Allocation{
uid: uida,
mcs: DefaultMCSAllocation(uidr, mcsr, 5),
client: client.Namespaces(),
}
err := c.Next(&kapi.Namespace{ObjectMeta: kapi.ObjectMeta{Name: "test"}})
if !testCase.errFn(err) {
t.Errorf("%s: unexpected error: %v", s, err)
}
if len(client.Actions) != testCase.actions {
t.Errorf("%s: expected %d actions: %v", s, testCase.actions, client.Actions)
}
if uida.Free() != 5 {
t.Errorf("%s: should not have allocated uid: %d/%d", s, uida.Free(), uidr.Size())
}
}
}
func TestRepair(t *testing.T) {
var action testclient.FakeAction
client := &testclient.Fake{
ReactFn: func(a testclient.FakeAction) (runtime.Object, error) {
action = a
list := &kapi.NamespaceList{
Items: []kapi.Namespace{
{ObjectMeta: kapi.ObjectMeta{Name: "default"}},
},
}
return list, nil
},
}
alloc := &fakeRange{
Range: &kapi.RangeAllocation{},
}
uidr, _ := uid.NewRange(10, 20, 2)
repair := NewRepair(0*time.Second, client.Namespaces(), uidr, alloc)
err := repair.RunOnce()
if err != nil {
t.Fatal(err)
}
if alloc.Updated == nil {
t.Fatalf("did not store range: %#v", alloc)
}
if alloc.Updated.Range != "10-20/2" {
t.Errorf("didn't store range properly: %#v", alloc.Updated)
}
if len(alloc.Updated.Data) != 0 {
t.Errorf("data wasn't empty: %#v", alloc.Updated)
}
}
func TestController(t *testing.T) {
var action testclient.FakeAction
client := &testclient.Fake{
ReactFn: func(a testclient.FakeAction) (runtime.Object, error) {
action = a
return (*kapi.Namespace)(nil), nil
},
}
uidr, _ := uid.NewRange(10, 20, 2)
mcsr, _ := mcs.NewRange("s0:", 10, 2)
uida := uidallocator.NewInMemory(uidr)
c := Allocation{
uid: uida,
mcs: DefaultMCSAllocation(uidr, mcsr, 5),
client: client.Namespaces(),
}
err := c.Next(&kapi.Namespace{ObjectMeta: kapi.ObjectMeta{Name: "test"}})
if err != nil {
t.Fatal(err)
}
got := action.Value.(*kapi.Namespace)
if got.Annotations[security.UIDRangeAnnotation] != "10/2" {
t.Errorf("unexpected annotation: %#v", got)
}
if got.Annotations[security.MCSAnnotation] != "s0:c1,c0" {
t.Errorf("unexpected annotation: %#v", got)
}
if !uida.Has(uid.Block{Start: 10, End: 11}) {
t.Errorf("did not allocate uid: %#v", uida)
}
}
func TestAllocate(t *testing.T) {
ranger, _ := uid.NewRange(0, 9, 2)
r := New(ranger, allocator.NewContiguousAllocationInterface)
if f := r.Free(); f != 5 {
t.Errorf("unexpected free %d", f)
}
found := util.NewStringSet()
count := 0
for r.Free() > 0 {
block, err := r.AllocateNext()
if err != nil {
t.Fatalf("error @ %d: %v", count, err)
}
count++
if !ranger.Contains(block) {
t.Fatalf("allocated %s which is outside of %s", block, ranger)
}
if found.Has(block.String()) {
t.Fatalf("allocated %s twice @ %d", block, count)
}
found.Insert(block.String())
}
if _, err := r.AllocateNext(); err != ErrFull {
t.Fatal(err)
}
released := uid.Block{2, 3}
if err := r.Release(released); err != nil {
t.Fatal(err)
}
if f := r.Free(); f != 1 {
t.Errorf("unexpected free %d", f)
}
block, err := r.AllocateNext()
if err != nil {
t.Fatal(err)
}
if released != block {
t.Errorf("unexpected %s : %s", block, released)
}
if err := r.Release(released); err != nil {
t.Fatal(err)
}
if err := r.Allocate(uid.Block{11, 11}); err != ErrNotInRange {
t.Fatal(err)
}
if err := r.Allocate(uid.Block{8, 11}); err != ErrNotInRange {
t.Fatal(err)
}
if f := r.Free(); f != 1 {
t.Errorf("unexpected free %d", f)
}
if err := r.Allocate(released); err != nil {
t.Fatal(err)
}
if f := r.Free(); f != 0 {
t.Errorf("unexpected free %d", f)
}
}