func NewTestEventEtcdRegistry(t *testing.T) (*tools.FakeEtcdClient, generic.Registry) { f := tools.NewFakeEtcdClient(t) f.TestIndex = true s := tools.NewEtcdStorage(f, testapi.Codec(), etcdtest.PathPrefix()) return f, NewEtcdRegistry(s, testTTL) }
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient, tools.StorageInterface) { fakeEtcdClient := tools.NewFakeEtcdClient(t) fakeEtcdClient.TestIndex = true etcdStorage := tools.NewEtcdStorage(fakeEtcdClient, latest.Codec, etcdtest.PathPrefix()) storage, statusStorage := NewStorage(etcdStorage) return storage, statusStorage, fakeEtcdClient, etcdStorage }
func NewTestEtcdRegistryWithPods(client tools.EtcdClient) *Registry { etcdStorage := tools.NewEtcdStorage(client, latest.Codec, etcdtest.PathPrefix()) podStorage := podetcd.NewStorage(etcdStorage, nil) endpointStorage := endpointetcd.NewStorage(etcdStorage) registry := NewRegistry(etcdStorage, pod.NewRegistry(podStorage.Pod), endpoint.NewRegistry(endpointStorage)) return registry }
// NewEtcdStorage returns a StorageInterface for the provided arguments or an error if the version // is incorrect. func NewEtcdStorage(client tools.EtcdClient, version string, prefix string) (etcdStorage tools.StorageInterface, err error) { if version == "" { version = latest.Version } versionInterfaces, err := latest.InterfacesFor(version) if err != nil { return etcdStorage, err } return tools.NewEtcdStorage(client, versionInterfaces.Codec, prefix), nil }
func TestWatch(t *testing.T) { client := framework.NewEtcdClient() etcdStorage := tools.NewEtcdStorage(client, testapi.Codec(), etcdtest.PathPrefix()) framework.WithEtcdKey(func(key string) { key = etcdtest.AddPrefix(key) resp, err := client.Set(key, runtime.EncodeOrDie(testapi.Codec(), &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}), 0) if err != nil { t.Fatalf("unexpected error: %v", err) } expectedVersion := resp.Node.ModifiedIndex // watch should load the object at the current index w, err := etcdStorage.Watch(key, 0, tools.Everything) if err != nil { t.Fatalf("Unexpected error: %v", err) } event := <-w.ResultChan() if event.Type != watch.Added || event.Object == nil { t.Fatalf("expected first value to be set to ADDED, got %#v", event) } // version should match what we set pod := event.Object.(*api.Pod) if pod.ResourceVersion != strconv.FormatUint(expectedVersion, 10) { t.Errorf("expected version %d, got %#v", expectedVersion, pod) } // should be no events in the stream select { case event, ok := <-w.ResultChan(): if !ok { t.Fatalf("channel closed unexpectedly") } t.Fatalf("unexpected object in channel: %#v", event) default: } // should return the previously deleted item in the watch, but with the latest index resp, err = client.Delete(key, false) if err != nil { t.Fatalf("unexpected error: %v", err) } expectedVersion = resp.Node.ModifiedIndex event = <-w.ResultChan() if event.Type != watch.Deleted { t.Errorf("expected deleted event %#v", event) } pod = event.Object.(*api.Pod) if pod.ResourceVersion != strconv.FormatUint(expectedVersion, 10) { t.Errorf("expected version %d, got %#v", expectedVersion, pod) } }) }
func TestGetServersToValidate(t *testing.T) { master := Master{} config := Config{} fakeClient := tools.NewFakeEtcdClient(t) fakeClient.Machines = []string{"http://machine1:4001", "http://machine2", "http://machine3:4003"} config.DatabaseStorage = tools.NewEtcdStorage(fakeClient, latest.Codec, etcdtest.PathPrefix()) master.nodeRegistry = registrytest.NewMinionRegistry([]string{"node1", "node2"}, api.NodeResources{}) servers := master.getServersToValidate(&config) if len(servers) != 5 { t.Errorf("unexpected server list: %#v", servers) } for _, server := range []string{"scheduler", "controller-manager", "etcd-0", "etcd-1", "etcd-2"} { if _, ok := servers[server]; !ok { t.Errorf("server list missing: %s", server) } } }
func TestSetObj(t *testing.T) { client := framework.NewEtcdClient() etcdStorage := tools.NewEtcdStorage(client, testapi.Codec(), "") framework.WithEtcdKey(func(key string) { testObject := api.ServiceAccount{ObjectMeta: api.ObjectMeta{Name: "foo"}} if err := etcdStorage.SetObj(key, &testObject, nil, 0); err != nil { t.Fatalf("unexpected error: %v", err) } resp, err := client.Get(key, false, false) if err != nil || resp.Node == nil { t.Fatalf("unexpected error: %v %v", err, resp) } decoded, err := testapi.Codec().Decode([]byte(resp.Node.Value)) if err != nil { t.Fatalf("unexpected response: %#v", resp.Node) } result := *decoded.(*api.ServiceAccount) if !api.Semantic.DeepEqual(testObject, result) { t.Errorf("expected: %#v got: %#v", testObject, result) } }) }
func NewTestGenericEtcdRegistry(t *testing.T) (*tools.FakeEtcdClient, *Etcd) { f := tools.NewFakeEtcdClient(t) f.TestIndex = true s := tools.NewEtcdStorage(f, testapi.Codec(), etcdtest.PathPrefix()) strategy := &testRESTStrategy{api.Scheme, api.SimpleNameGenerator, true, false, true} podPrefix := "/pods" return f, &Etcd{ NewFunc: func() runtime.Object { return &api.Pod{} }, NewListFunc: func() runtime.Object { return &api.PodList{} }, EndpointName: "pods", CreateStrategy: strategy, UpdateStrategy: strategy, KeyRootFunc: func(ctx api.Context) string { return podPrefix }, KeyFunc: func(ctx api.Context, id string) (string, error) { return path.Join(podPrefix, id), nil }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.Pod).Name, nil }, Storage: s, } }
func TestExtractObj(t *testing.T) { client := framework.NewEtcdClient() etcdStorage := tools.NewEtcdStorage(client, testapi.Codec(), "") framework.WithEtcdKey(func(key string) { testObject := api.ServiceAccount{ObjectMeta: api.ObjectMeta{Name: "foo"}} coded, err := testapi.Codec().Encode(&testObject) if err != nil { t.Fatalf("unexpected error: %v", err) } _, err = client.Set(key, string(coded), 0) if err != nil { t.Fatalf("unexpected error: %v", err) } result := api.ServiceAccount{} if err := etcdStorage.ExtractObj(key, &result, false); err != nil { t.Fatalf("unexpected error: %v", err) } // Propagate ResourceVersion (it is set automatically). testObject.ObjectMeta.ResourceVersion = result.ObjectMeta.ResourceVersion if !api.Semantic.DeepEqual(testObject, result) { t.Errorf("expected: %#v got: %#v", testObject, result) } }) }
func newEtcdStorage(t *testing.T) (*tools.FakeEtcdClient, tools.StorageInterface) { fakeEtcdClient := tools.NewFakeEtcdClient(t) fakeEtcdClient.TestIndex = true etcdStorage := tools.NewEtcdStorage(fakeEtcdClient, latest.Codec, etcdtest.PathPrefix()) return fakeEtcdClient, etcdStorage }
func NewTestEtcdRegistry(client tools.EtcdClient) *Registry { storage := tools.NewEtcdStorage(client, latest.Codec, etcdtest.PathPrefix()) registry := NewRegistry(storage, nil, nil) return registry }