Golang Namespace.ExecuteCallCount方法代码示例

		Expect(sbox.LockCallCount()).To(Equal(1))
		Expect(sbox.UnlockCallCount()).To(Equal(1))
	})

	It("adds a dummy link to the sandbox namespace", func() {
		ns.ExecuteStub = func(callback func(*os.File) error) error {
			Expect(linkFactory.CreateDummyCallCount()).To(Equal(0))
			err := callback(nil)
			Expect(linkFactory.CreateDummyCallCount()).To(Equal(1))
			return err
		}

		err := startDNS.Execute(context)
		Expect(err).NotTo(HaveOccurred())

		Expect(ns.ExecuteCallCount()).To(Equal(1))

		Expect(linkFactory.CreateDummyCallCount()).To(Equal(1))
		linkName := linkFactory.CreateDummyArgsForCall(0)
		Expect(linkName).To(Equal("dns0"))
	})

	It("sets the address on the dummy device in the sandbox namespace", func() {
		ns.ExecuteStub = func(callback func(*os.File) error) error {
			Expect(addressManager.AddAddressCallCount()).To(Equal(0))
			err := callback(nil)
			Expect(addressManager.AddAddressCallCount()).To(Equal(1))
			return err
		}

		err := startDNS.Execute(context)

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

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

	It("executes the command in the specified namespace", func() {
		err := inNamespace.Execute(context)
		Expect(err).NotTo(HaveOccurred())

		Expect(namespace.ExecuteCallCount()).To(Equal(1))
	})

	It("executes the command with the correct context", func() {
		err := inNamespace.Execute(context)
		Expect(err).NotTo(HaveOccurred())

		Expect(command.ExecuteCallCount()).To(Equal(1))
		Expect(command.ExecuteArgsForCall(0)).To(Equal(context))
	})

	Context("when namespace execute fails", func() {
		BeforeEach(func() {
			namespace.ExecuteReturns(errors.New("go away"))
		})

		fakeNetlinker.NeighDeserializeReturns(&netlink.Neigh{}, nil)
	})

	It("subscribes in the sandbox namespace", func() {
		targetNS.ExecuteStub = func(callback func(*os.File) error) error {
			defer GinkgoRecover()
			Expect(fakeNetlinker.SubscribeCallCount()).To(Equal(0))
			err := callback(nil)
			Expect(fakeNetlinker.SubscribeCallCount()).To(Equal(1))
			return err
		}

		err := mySubscriber.Subscribe(targetNS, neighChan, doneChan)
		Expect(err).NotTo(HaveOccurred())

		Expect(targetNS.ExecuteCallCount()).To(Equal(1))
	})

	It("faithfully represents the netlink Neighbor in the return type", func() {
		someMac, _ := net.ParseMAC("01:02:03:04:05:06")
		fakeNetlinker.NeighDeserializeReturns(&netlink.Neigh{
			LinkIndex:    1,
			Family:       2,
			State:        netlink.NUD_STALE,
			Type:         4,
			Flags:        5,
			IP:           net.ParseIP("1.2.3.4"),
			HardwareAddr: someMac,
		}, nil)

		err := mySubscriber.Subscribe(targetNS, neighChan, doneChan)

			resolved <- neighbor

			ready = make(chan error, 1)
		})

		JustBeforeEach(func() {
			close(resolved)
		})

		AfterEach(func() {
			Eventually(ready).Should(BeClosed())
		})

		It("finds the vxlan device in the sandbox namespace", func() {
			ns.ExecuteStub = func(callback func(_ *os.File) error) error {
				if ns.ExecuteCallCount() == 1 {
					Expect(netlinker.LinkByNameCallCount()).To(Equal(0))
				}
				callback(nil)
				if ns.ExecuteCallCount() == 1 {
					Expect(netlinker.LinkByNameCallCount()).To(Equal(1))
				}
				return nil
			}

			inserter.HandleResolvedNeighbors(ready, ns, "some-vxlan-name", resolved)
			Eventually(ready).Should(BeClosed())

			Expect(ns.ExecuteCallCount()).To(Equal(2))
			Expect(netlinker.LinkByNameArgsForCall(0)).To(Equal("some-vxlan-name"))
		})

		It("it calls StartMonitor inside the HostNamespace", func() {

			hostNS.ExecuteStub = func(callback func(_ *os.File) error) error {
				Expect(fakeWatcher.StartMonitorCallCount()).To(Equal(0))
				callback(nil)
				Expect(fakeWatcher.StartMonitorCallCount()).To(Equal(1))
				return nil
			}

			err := startMonitor.Execute(context)
			Expect(err).NotTo(HaveOccurred())

			Expect(sandboxRepository.GetCallCount()).To(Equal(1))
			Expect(sandboxRepository.GetArgsForCall(0)).To(Equal("some-sandbox"))

			Expect(hostNS.ExecuteCallCount()).To(Equal(1))

			ns, linkName := fakeWatcher.StartMonitorArgsForCall(0)
			Expect(ns).To(Equal(sandboxNS))
			Expect(linkName).To(Equal("some-vxlan-name"))
		})

		Context("when getting the sandbox namespace fails", func() {
			BeforeEach(func() {
				sandboxRepository.GetReturns(nil, errors.New("potato"))
			})

			It("wraps and propogates the error", func() {
				err := startMonitor.Execute(context)
				Expect(err).To(MatchError("getting sandbox namespace: potato"))
			})

		})
	})

	Context("when there are no veth devices in the sandbox", func() {
		It("removes the vxlan device in the sandbox namespace", func() {
			sandboxNS.ExecuteStub = func(callback func(ns *os.File) error) error {
				Expect(linkFactory.DeleteLinkByNameCallCount()).To(Equal(0))
				err := callback(nil)
				Expect(linkFactory.DeleteLinkByNameCallCount()).To(Equal(1))
				return err
			}

			err := cleanupSandboxCommand.Execute(context)
			Expect(err).NotTo(HaveOccurred())

			Expect(sandboxNS.ExecuteCallCount()).To(Equal(1))
			Expect(linkFactory.DeleteLinkByNameArgsForCall(0)).To(Equal("some-vxlan"))
		})

		It("destroys the sandbox", func() {
			err := cleanupSandboxCommand.Execute(context)
			Expect(err).NotTo(HaveOccurred())

			Expect(sandboxRepo.DestroyCallCount()).To(Equal(1))
			Expect(sandboxRepo.DestroyArgsForCall(0)).To(Equal("sandbox-name"))
		})

		Context("when destroy fails with AlreadyDestroyedError", func() {
			BeforeEach(func() {
				sandboxRepo.DestroyReturns(sandbox.AlreadyDestroyedError)
			})