. "github.com/cloudfoundry/hm9000/desiredstatefetcher"
	"github.com/cloudfoundry/hm9000/testhelpers/app"
	. "github.com/cloudfoundry/hm9000/testhelpers/custommatchers"
	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

var _ = Describe("Desired State Server Response JSON", func() {
	var (
		a        app.App
		response DesiredStateServerResponse
	)
	BeforeEach(func() {
		a = app.NewApp()

		desired, _ := json.Marshal(a.DesiredState(0))
		responseJson := fmt.Sprintf(`
        {
            "results":{"%s":%s},
            "bulk_token":{"id":17}
        }
        `, a.AppGuid, string(desired))

		var err error
		response, err = NewDesiredStateServerResponse([]byte(responseJson))
		Ω(err).ShouldNot(HaveOccured())
	})

	It("can parse from JSON", func() {
		Ω(response.Results).Should(HaveLen(1))
		Ω(response.Results[a.AppGuid]).Should(EqualDesiredState(a.DesiredState(0)))
Exemple #2
0
		app1 = app.NewApp()
		app2 = app.NewApp()
		app3 = app.NewApp()

		store = NewStore(conf, etcdAdapter)
	})

	AfterEach(func() {
		etcdAdapter.Disconnect()
	})

	Describe("Saving desired state ", func() {
		BeforeEach(func() {
			err := store.SaveDesiredState([]models.DesiredAppState{
				app1.DesiredState(0),
				app2.DesiredState(0),
			})
			Ω(err).ShouldNot(HaveOccured())
		})

		It("can stores the passed in desired state", func() {
			nodes, err := etcdAdapter.List("/desired")
			Ω(err).ShouldNot(HaveOccured())
			Ω(nodes).Should(HaveLen(2))
			Ω(nodes).Should(ContainElement(storeadapter.StoreNode{
				Key:   "/desired/" + app1.AppGuid + "-" + app1.AppVersion,
				Value: app1.DesiredState(0).ToJson(),
				TTL:   conf.DesiredStateTTL - 1,
			}))
			Ω(nodes).Should(ContainElement(storeadapter.StoreNode{
			Ω(query.Get("bulk_token")).Should(Equal("{}"))
		})

		Context("when a response with desired state is received", func() {
			var (
				a1 app.App
				a2 app.App
			)

			BeforeEach(func() {
				a1 = app.NewApp()
				a2 = app.NewApp()

				response = DesiredStateServerResponse{
					Results: map[string]models.DesiredAppState{
						a1.AppGuid: a1.DesiredState(0),
						a2.AppGuid: a2.DesiredState(0),
					},
					BulkToken: BulkToken{
						Id: 5,
					},
				}

				httpClient.LastRequest().Succeed(response.ToJson())
			})

			It("should store the desired states", func() {
				desired, _ := store.GetDesiredState()
				Ω(desired).Should(HaveLen(2))
				Ω(desired).Should(ContainElement(EqualDesiredState(a1.DesiredState(0))))
				Ω(desired).Should(ContainElement(EqualDesiredState(a2.DesiredState(0))))
Exemple #4
0
		}
		etcdStoreAdapter.Set([]storeadapter.StoreNode{node})
	}

	Context("When /desired and /actual are missing", func() {
		It("Should not send any start or stop messages", func() {
			startMessages, stopMessages, err := analyzer.Analyze()
			Ω(err).ShouldNot(HaveOccured())
			Ω(startMessages).Should(BeEmpty())
			Ω(stopMessages).Should(BeEmpty())
		})
	})

	Context("When /desired and /actual are empty", func() {
		BeforeEach(func() {
			desired := a1.DesiredState(42)
			actual := a2.GetInstance(0).Heartbeat(30)

			insertDesiredIntoStore(desired)
			insertActualIntoStore(actual)

			etcdStoreAdapter.Delete("/desired/" + desired.StoreKey())
			etcdStoreAdapter.Delete("/actual/" + actual.StoreKey())
		})

		It("Should not send any start or stop messages", func() {
			startMessages, stopMessages, err := analyzer.Analyze()
			Ω(err).ShouldNot(HaveOccured())
			Ω(startMessages).Should(BeEmpty())
			Ω(stopMessages).Should(BeEmpty())
		})
Exemple #5
0
			err = store.BumpActualFreshness(time.Unix(17, 0))
			Ω(err).Should(Equal(errIn))

			store.Reset()

			err = store.BumpDesiredFreshness(time.Unix(12, 0))
			Ω(err).ShouldNot(HaveOccured())

			err = store.BumpActualFreshness(time.Unix(12, 0))
			Ω(err).ShouldNot(HaveOccured())
		})
	})

	Describe("Setting, getting, and deleting desired state", func() {
		It("should set, get, and delete the desired state", func() {
			desired1 := app1.DesiredState(0)
			desired2 := app2.DesiredState(0)

			err := store.SaveDesiredState([]models.DesiredAppState{desired1, desired1, desired2})
			Ω(err).ShouldNot(HaveOccured())

			desired, err := store.GetDesiredState()
			Ω(err).ShouldNot(HaveOccured())
			Ω(desired).Should(HaveLen(2))
			Ω(desired).Should(ContainElement(EqualDesiredState(desired1)))
			Ω(desired).Should(ContainElement(EqualDesiredState(desired2)))

			desired2.NumberOfInstances = 17
			desired3 := app.NewApp().DesiredState(2)

			err = store.SaveDesiredState([]models.DesiredAppState{desired2, desired3})
	var (
		fetcher    *desiredstatefetcher.DesiredStateFetcher
		a1         app.App
		a2         app.App
		a3         app.App
		resultChan chan desiredstatefetcher.DesiredStateFetcherResult
	)

	BeforeEach(func() {
		resultChan = make(chan desiredstatefetcher.DesiredStateFetcherResult, 1)
		a1 = app.NewApp()
		a2 = app.NewApp()
		a3 = app.NewApp()

		stateServer.SetDesiredState([]models.DesiredAppState{
			a1.DesiredState(0),
			a2.DesiredState(0),
			a3.DesiredState(0),
		})

		fetcher = desiredstatefetcher.New(conf, natsRunner.MessageBus, store.NewStore(conf, storeAdapter), httpclient.NewHttpClient(), &timeprovider.RealTimeProvider{})
		fetcher.Fetch(resultChan)
	})

	It("requests for the first set of data from the CC and stores the response", func() {
		var node storeadapter.StoreNode
		var err error
		Eventually(func() error {
			node, err = storeAdapter.Get("/desired/" + a1.AppGuid + "-" + a1.AppVersion)
			return err
		}, 1, 0.1).ShouldNot(HaveOccured())