func init() {
	Describe("configureNetworks", func() {
		var (
			action ConfigureNetworksAction
		)

		BeforeEach(func() {
			action = NewConfigureNetworks(fakeactions.NewFakeAgentKiller())
		})

		AssertActionIsAsynchronous(action)
		AssertActionIsPersistent(action)
		AssertActionIsLoggable(action)

		AssertActionIsNotCancelable(action)
		AssertActionIsResumable(action)

		It("is asynchronous", func() {
			Expect(action.IsAsynchronous()).To(BeTrue())
		})

		It("is persistent because director expects configure_networks task to become done after agent is restarted", func() {
			Expect(action.IsPersistent()).To(BeTrue())
		})

		Describe("Run", func() {
			// restarts agent process
		})
	})
}
func init() {
	Describe("configureNetworks", func() {
		var (
			action ConfigureNetworksAction
		)

		BeforeEach(func() {
			action = NewConfigureNetworks(fakeactions.NewFakeAgentKiller())
		})

		It("is asynchronous", func() {
			Expect(action.IsAsynchronous()).To(BeTrue())
		})

		It("is persistent because director expects configure_networks task to become done after agent is restarted", func() {
			Expect(action.IsPersistent()).To(BeTrue())
		})

		Describe("Run", func() {
			// restarts agent process
		})

		Describe("Resume", func() {
			It("returns ok because agent was restarted and connections were re-initialized", func() {
				value, err := action.Resume()
				Expect(value).To(Equal("ok"))
				Expect(err).ToNot(HaveOccurred())
			})
		})
	})
}
func init() {
	Describe("prepareNetworkChange", func() {
		var (
			action PrepareNetworkChangeAction
			fs     *fakesys.FakeFileSystem

			settingsService *fakesettings.FakeSettingsService
		)

		BeforeEach(func() {
			fs = fakesys.NewFakeFileSystem()
			settingsService = &fakesettings.FakeSettingsService{}
			action = NewPrepareNetworkChange(fs, settingsService, fakeactions.NewFakeAgentKiller())
		})

		It("is synchronous", func() {
			Expect(action.IsAsynchronous()).To(BeFalse())
		})

		It("is not persistent", func() {
			Expect(action.IsPersistent()).To(BeFalse())
		})

		It("invalidates settings so that load settings cannot fall back on old settings", func() {
			resp, err := action.Run()
			Expect(err).NotTo(HaveOccurred())
			Expect(resp).To(Equal("ok"))

			Expect(settingsService.SettingsWereInvalidated).To(BeTrue())
		})

		Context("when settings invalidation succeeds", func() {
			Context("when the network rules file can be removed", func() {
				It("removes the network rules file", func() {
					fs.WriteFile("/etc/udev/rules.d/70-persistent-net.rules", []byte{})

					resp, err := action.Run()
					Expect(err).NotTo(HaveOccurred())
					Expect(resp).To(Equal("ok"))

					Expect(fs.FileExists("/etc/udev/rules.d/70-persistent-net.rules")).To(BeFalse())
				})
			})

			Context("when the network rules file cannot be removed", func() {
				BeforeEach(func() {
					fs.RemoveAllError = errors.New("fake-remove-all-error")
				})

				It("returns error from removing the network rules file", func() {
					resp, err := action.Run()
					Expect(err).To(HaveOccurred())
					Expect(err.Error()).To(ContainSubstring("fake-remove-all-error"))

					Expect(resp).To(BeNil())
				})
			})
		})

		Context("when settings invalidation fails", func() {
			BeforeEach(func() {
				settingsService.InvalidateSettingsError = errors.New("fake-invalidate-error")
			})

			It("returns error early if settings err invalidating", func() {
				resp, err := action.Run()
				Expect(err).To(HaveOccurred())
				Expect(err.Error()).To(ContainSubstring("fake-invalidate-error"))

				Expect(resp).To(BeNil())
			})

			It("does not remove the network rules file", func() {
				fs.WriteFile("/etc/udev/rules.d/70-persistent-net.rules", []byte{})

				action.Run()
				Expect(fs.FileExists("/etc/udev/rules.d/70-persistent-net.rules")).To(BeTrue())
			})
		})
	})
}