Golang Namespace.NameReturns方法代码示例

var _ = Describe("ExecuteInNamespace", func() {
	var (
		context   *fakes.Context
		namespace *fakes.Namespace
		command   *fakes.Command

		inNamespace commands.InNamespace
	)

	BeforeEach(func() {
		context = &fakes.Context{}
		command = &fakes.Command{}
		command.StringReturns("some-command")

		namespace = &fakes.Namespace{}
		namespace.NameReturns("namespace-name")

		namespace.ExecuteStub = func(callback func(*os.File) error) error {
			Expect(command.ExecuteCallCount()).To(Equal(0))

			err := callback(nil)

			Expect(command.ExecuteCallCount()).To(Equal(1))
			return err
		}

		inNamespace = commands.InNamespace{
			Namespace: namespace,
			Command:   command,
		}
	})

var _ = Describe("Reloader", func() {
	var (
		monitorReloader *reloader.Reloader
		watcher         *fakes.MissWatcher
		ns              *fakes.Namespace
	)

	BeforeEach(func() {
		watcher = &fakes.MissWatcher{}
		monitorReloader = &reloader.Reloader{
			Watcher: watcher,
		}
		ns = &fakes.Namespace{}

		ns.NameReturns("/some/sbox/path/vni-some-sandbox")
	})

	Describe("Callback", func() {
		It("restart the monitor for the given namespace", func() {
			err := monitorReloader.Callback(ns)
			Expect(err).NotTo(HaveOccurred())

			Expect(watcher.StartMonitorCallCount()).To(Equal(1))
			calledNS, vxlanDev := watcher.StartMonitorArgsForCall(0)
			Expect(calledNS).To(Equal(ns))
			Expect(vxlanDev).To(Equal("vxlansome-sandbox"))
		})

		Context("failure cases", func() {
			It("returns an error when the sandbox name is not valid", func() {

		arpInserter = &fakes.ARPInserter{}
		arpInserter.HandleResolvedNeighborsStub = func(ready chan error, _ namespace.Namespace, _ string, _ <-chan watcher.Neighbor) {
			close(ready)
		}

		missWatcher = watcher.New(logger, sub, locker, resolver, arpInserter)

		ns.ExecuteStub = func(callback func(ns *os.File) error) error {
			err := callback(nil)
			if err != nil {
				return fmt.Errorf("callback failed: %s", err)
			}
			return nil
		}
		ns.NameReturns("some-namespace")
	})

	Describe("StartMonitor", func() {
		It("subscribes to sandbox l3 misses", func() {
			missWatcher.StartMonitor(ns, vxlanLinkName)

			Expect(sub.SubscribeCallCount()).To(Equal(1))

			targetNS, _, doneCh := sub.SubscribeArgsForCall(0)
			Expect(targetNS).To(Equal(ns))
			Consistently(doneCh).ShouldNot(BeClosed())
		})

		It("logs entry and exit", func() {
			missWatcher.StartMonitor(ns, vxlanLinkName)

							SandboxName:   "some-sandbox-name",
							ListenAddress: "some-dns-address",
						},
					),
				}))
		})
	})

	Describe("IdempotentlyCreateVxlan", func() {
		var sandboxNS *fakes.Namespace

		It("should return a command group that idempotently creates the vxlan device", func() {
			hostNamespace := &fakes.Namespace{NameStub: func() string { return "host namespace sentinel" }}

			sandboxNS = &fakes.Namespace{}
			sandboxNS.NameReturns("/sandbox/repo/some-sandbox-name")

			missWatcher := &fakes.MissWatcher{}
			b := container.CommandBuilder{
				HostNamespace: hostNamespace,
				MissWatcher:   missWatcher,
			}

			cmd := b.IdempotentlyCreateVxlan("some-vxlan-name", "some-sandbox-name", sandboxNS)

			Expect(cmd).To(Equal(
				commands.All(
					commands.InNamespace{
						Namespace: sandboxNS,
						Command: commands.SetLinkUp{
							LinkName: "some-vxlan-name",

		sandboxNS             *fakes.Namespace
		linkFactory           *fakes.LinkFactory
		cleanupSandboxCommand commands.CleanupSandbox
		missWatcher           *fakes.MissWatcher
		namespaceRepository   *fakes.Repository
		sandboxRepo           *fakes.SandboxRepository
	)

	BeforeEach(func() {
		context = &fakes.Context{}

		logger = lagertest.NewTestLogger("test")
		context.LoggerReturns(logger)

		sandboxNS = &fakes.Namespace{}
		sandboxNS.NameReturns("sandbox-name")

		sbox = &fakes.Sandbox{}
		sbox.NamespaceReturns(sandboxNS)

		linkFactory = &fakes.LinkFactory{}
		context.LinkFactoryReturns(linkFactory)
		missWatcher = &fakes.MissWatcher{}
		namespaceRepository = &fakes.Repository{}

		sandboxRepo = &fakes.SandboxRepository{}
		sandboxRepo.GetStub = func(key string) (sandbox.Sandbox, error) {
			if key == "sandbox-name" {
				return sbox, nil
			}
			return nil, sandbox.NotFoundError

			Invoker:        invoker,
			LinkFactory:    linkFactory,
			Watcher:        missWatcher,
			SandboxFactory: sandboxFactory,
			Sandboxes:      map[string]sandbox.Sandbox{},
		}
	})

	Describe("ForEach", func() {
		BeforeEach(func() {
			sbox, err := sandboxRepo.Create("some-sandbox-name")
			Expect(err).NotTo(HaveOccurred())
			Expect(sbox).NotTo(BeNil())

			sandboxCallback.CallbackReturns(nil)
			sboxNamespace.NameReturns("some-sandbox-name")
		})

		It("executes the callback for each sandbox in the repo", func() {
			err := sandboxRepo.ForEach(sandboxCallback)
			Expect(err).NotTo(HaveOccurred())

			Expect(sandboxCallback.CallbackCallCount()).To(Equal(1))
			ns := sandboxCallback.CallbackArgsForCall(0)
			Expect(ns).To(Equal(sboxNamespace))
		})

		It("locks and unlocks", func() {
			Expect(locker.LockCallCount()).To(Equal(1))
			Expect(locker.UnlockCallCount()).To(Equal(1))