Example #1
0
func (u User) LoginTo(page *agouti.Page) {
	Expect(page.Navigate(u.testEnvVars.Hostname)).To(Succeed())
	Expect(page.Find("#login-btn").Click()).To(Succeed())
	Expect(page).To(HaveURL(u.testEnvVars.LoginURL + "login"))
	Expect(page.FindByName("username").Fill(u.username)).To(Succeed())
	Expect(page.FindByName("password").Fill(u.password)).To(Succeed())
	Expect(page.FindByButton("Sign in").Click()).To(Succeed())
	Expect(page).To(HaveURL(u.testEnvVars.Hostname + "/#/dashboard"))
}
Example #2
0
func (u User) LoginTo(page *agouti.Page) {
	Expect(page.Navigate(u.testEnvVars.Hostname + "/#/")).To(Succeed())
	var loginLink = page.First(".test-login")
	Eventually(loginLink).Should(BeFound())
	Expect(loginLink.Click()).To(Succeed())
	Eventually(page).Should(HaveURL(u.testEnvVars.LoginURL + "login"))
	Expect(page.FindByName("username").Fill(u.username)).To(Succeed())
	Expect(page.FindByName("password").Fill(u.password)).To(Succeed())
	Expect(page.FindByButton("Sign in").Click()).To(Succeed())
	Eventually(page.FindByButton("Authorize").Click())
	Eventually(page).Should(HaveURL(u.testEnvVars.Hostname + "/#/dashboard"))
}
Example #3
0
func testSelection(browserName string, newPage pageFunc) {
	Describe("selection test for "+browserName, func() {
		var (
			page      *agouti.Page
			server    *httptest.Server
			submitted bool
		)

		BeforeEach(func() {
			server = httptest.NewServer(http.HandlerFunc(func(response http.ResponseWriter, request *http.Request) {
				if request.Method == "POST" {
					submitted = true
				}
				html, _ := ioutil.ReadFile("test_page.html")
				response.Write(html)
			}))

			var err error
			page, err = newPage()
			Expect(err).NotTo(HaveOccurred())

			Expect(page.Size(640, 480)).To(Succeed())
			Expect(page.Navigate(server.URL)).To(Succeed())
		})

		AfterEach(func() {
			Expect(page.Destroy()).To(Succeed())
			server.Close()
		})

		It("should support asserting on element identity", func() {
			By("asserting on an element's existence", func() {
				Expect(page.Find("header")).To(BeFound())
				Expect(page.Find("header")).To(HaveCount(1))
				Expect(page.Find("not-a-header")).NotTo(BeFound())
			})

			By("comparing two selections for equality", func() {
				Expect(page.Find("#some_element")).To(EqualElement(page.FindByXPath("//div[@class='some-element']")))
				Expect(page.Find("#some_element")).NotTo(EqualElement(page.Find("header")))
			})
		})

		It("should support moving the mouse pointer over a selected element", func() {
			Expect(page.Find("#some_checkbox").MouseToElement()).To(Succeed())
			Expect(page.Click(agouti.SingleClick, agouti.LeftButton)).To(Succeed())
			Expect(page.Find("#some_checkbox")).To(BeSelected())
		})

		It("should support selecting elements", func() {
			By("finding an element by selection index", func() {
				Expect(page.All("option").At(0)).To(HaveText("first option"))
				Expect(page.All("select").At(1).First("option")).To(HaveText("third option"))
			})

			By("finding an element by chained selectors", func() {
				Expect(page.Find("header").Find("h1")).To(HaveText("Title"))
				Expect(page.Find("header").FindByXPath("//h1")).To(HaveText("Title"))
			})

			By("finding an element by link text", func() {
				Expect(page.FindByLink("Click Me").Attribute("href")).To(HaveSuffix("#new_page"))
			})

			By("finding an element by label text", func() {
				Expect(page.FindByLabel("Some Label")).To(HaveAttribute("value", "some labeled value"))
				Expect(page.FindByLabel("Some Container Label")).To(HaveAttribute("value", "some embedded value"))
			})

			By("finding an element by button text", func() {
				Expect(page.FindByButton("Some Button")).To(HaveAttribute("name", "some button name"))
				Expect(page.FindByButton("Some Input Button")).To(HaveAttribute("type", "button"))
				Expect(page.FindByButton("Some Submit Button")).To(HaveAttribute("type", "submit"))
			})

			By("finding an element by name attibute", func() {
				Expect(page.FindByName("some button name")).To(HaveAttribute("name", "some button name"))
			})

			By("finding multiple elements", func() {
				Expect(page.All("select").All("option")).To(BeVisible())
				Expect(page.All("h1,h2")).NotTo(BeVisible())
			})
		})

		It("should support retrieving element properties", func() {
			By("asserting on element text", func() {
				Expect(page.Find("header")).To(HaveText("Title"))
				Expect(page.Find("header")).NotTo(HaveText("Not-Title"))
				Expect(page.Find("header")).To(MatchText("T.+e"))
				Expect(page.Find("header")).NotTo(MatchText("X.+e"))
			})

			By("asserting on whether elements are active", func() {
				Expect(page.Find("#labeled_field")).NotTo(BeActive())
				Expect(page.Find("#labeled_field").Click()).To(Succeed())
				Expect(page.Find("#labeled_field")).To(BeActive())
			})

			By("asserting on element attributes", func() {
				Expect(page.Find("#some_checkbox")).To(HaveAttribute("type", "checkbox"))
			})

			By("asserting on element CSS", func() {
				Expect(page.Find("#some_element")).To(HaveCSS("color", "rgba(0, 0, 255, 1)"))
				Expect(page.Find("#some_element")).To(HaveCSS("color", "rgb(0, 0, 255)"))
				Expect(page.Find("#some_element")).To(HaveCSS("color", "blue"))
			})

			By("asserting on whether elements are selected", func() {
				Expect(page.Find("#some_checkbox")).NotTo(BeSelected())
				Expect(page.Find("#some_selected_checkbox")).To(BeSelected())
			})

			By("asserting on element visibility", func() {
				Expect(page.Find("header h1")).To(BeVisible())
				Expect(page.Find("header h2")).NotTo(BeVisible())
			})

			By("asserting on whether elements are enabled", func() {
				Expect(page.Find("#some_checkbox")).To(BeEnabled())
				Expect(page.Find("#some_disabled_checkbox")).NotTo(BeEnabled())
			})
		})

		It("should support element actions", func() {
			By("clicking on an element", func() {
				checkbox := page.Find("#some_checkbox")
				Expect(checkbox.Click()).To(Succeed())
				Expect(checkbox).To(BeSelected())
				Expect(checkbox.Click()).To(Succeed())
				Expect(checkbox).NotTo(BeSelected())
			})

			By("double-clicking on an element", func() {
				selection := page.Find("#double_click")
				Expect(selection.DoubleClick()).To(Succeed())
				Expect(selection).To(HaveText("double-click success"))
			})

			By("filling out an element", func() {
				Expect(page.Find("#some_input").Fill("some other value")).To(Succeed())
				Expect(page.Find("#some_input")).To(HaveAttribute("value", "some other value"))
			})

			// NOTE: PhantomJS regression causes crash on file upload
			if browserName != "PhantomJS" {
				By("uploading a file", func() {
					Expect(page.Find("#file_picker").UploadFile("test_page.html")).To(Succeed())
					var result string
					Expect(page.RunScript("return document.getElementById('file_picker').value;", nil, &result)).To(Succeed())
					Expect(result).To(HaveSuffix("test_page.html"))
				})
			}

			By("checking and unchecking a checkbox", func() {
				checkbox := page.Find("#some_checkbox")
				Expect(checkbox.Uncheck()).To(Succeed())
				Expect(checkbox).NotTo(BeSelected())
				Expect(checkbox.Check()).To(Succeed())
				Expect(checkbox).To(BeSelected())
				Expect(checkbox.Uncheck()).To(Succeed())
				Expect(checkbox).NotTo(BeSelected())
			})

			By("selecting an option by text", func() {
				selection := page.Find("#some_select")
				Expect(selection.All("option").At(1)).NotTo(BeSelected())
				Expect(selection.Select("second option")).To(Succeed())
				Expect(selection.All("option").At(1)).To(BeSelected())
			})

			By("submitting a form", func() {
				Expect(page.Find("#some_form").Submit()).To(Succeed())
				Eventually(func() bool { return submitted }).Should(BeTrue())
			})
		})
	})
}
Example #4
0
			Expect(page.Navigate(testEnvVars.Hostname + "/#/dashboard")).To(Succeed())
			Expect(page).To(HaveURL(testEnvVars.Hostname + "/#/"))
		})

	})

	It("should manage user authentication", func() {
		By("directing the user to a landing page", func() {
			Expect(page.Navigate(testEnvVars.Hostname)).To(Succeed())
		})

		By("allowing the user to click the login button and redirected to fill out the login form and submit it", func() {
			delayForRendering()
			Eventually(Expect(page.Find("#login-btn").Click()).To(Succeed()))
			Eventually(Expect(page).To(HaveURL(testEnvVars.LoginURL + "/login")))
			Expect(page.FindByName("username").Fill(testEnvVars.Username)).To(Succeed())
			Expect(page.FindByName("password").Fill(testEnvVars.Password)).To(Succeed())
			Expect(page.FindByButton("Sign in").Click()).To(Succeed())
			Expect(page).To(HaveURL(testEnvVars.Hostname + "/#/dashboard"))
		})

		/*
			By("allowing the user to log out", func() {
				Expect(page.Find("#logout").Click()).To(Succeed())
				Expect(page).To(HavePopupText("Are you sure?"))
				Expect(page.ConfirmPopup()).To(Succeed())
				Eventually(page).Should(HaveTitle("Login"))
			})
		*/
	})
Example #5
0
		BeforeEach(func() {
			var err error
			page, err = agoutiDriver.NewPage()
			Expect(err).NotTo(HaveOccurred())
		})

		AfterEach(func() {
			Expect(page.Destroy()).To(Succeed())
		})
		It("provide a web interface to the API", func() {
			By("having a root page", func() {
				Expect(page.Navigate("http://" + address)).To(Succeed())
			})

			By("allowing the user to fill out the form and run a simulation", func() {
				Eventually(page.FindByName("NumHosts")).Should(BeFound())
				Expect(page.FindByName("NumHosts").Fill("100")).To(Succeed())
				Expect(page.FindByName("NumApps").Fill("300")).To(Succeed())
				Expect(page.FindByName("MeanInstancesPerApp").Fill("5")).To(Succeed())
				Expect(page.FindByButton("Simulate").Click()).To(Succeed())
			})

			By("showing a histogram of app sizes", func() {
				Eventually(page.HTML).Should(ContainSubstring(`Size (instances)`))
				Eventually(page.HTML).Should(ContainSubstring(`40</text>`)) // tick mark on y axis
			})
		})
	})

})
	Describe("Phone list view", func() {
		BeforeEach(func() {
			var err error
			page, err = agoutiDriver.NewPage()
			Expect(err).NotTo(HaveOccurred())
			Expect(page.Navigate("http://localhost:8080/#/phones")).To(Succeed())
		})

		AfterEach(func() {
			Expect(page.Destroy()).To(Succeed())
		})

		It("should filter the phone list as a user types into the search box", func() {

			phonesInList := page.Find("ul.phones").All("li")
			query := page.FindByName("query")

			Eventually(phonesInList).Should(HaveCount(20))
			Expect(query.Fill("nexus")).To(Succeed())
			Eventually(phonesInList).Should(HaveCount(1))
			Expect(query.Fill("motorola")).To(Succeed()) // Note: Fill clears automatically
			Eventually(phonesInList).Should(HaveCount(8))
		})

		It("should be possible to control phone order via the drop down select box", func() {

			phoneNameColumn := page.Find("ul.phones").AllByName("phone-name")
			query := page.FindByName("query")
			selected := page.Find("select")

			Expect(query.Fill("tablet")).To(Succeed()) //let's narrow the dataset to make the test assertions shorter
		var err error
		page, err = agoutiDriver.NewPage()
		Expect(err).NotTo(HaveOccurred())
	})

	AfterEach(func() {
		Expect(page.Destroy()).To(Succeed())
	})

	It("should manage user authentication", func() {
		By("redirecting the user to the login form from the webapp page", func() {
			Expect(page.Navigate(AcceptanceSettings("webappUrl"))).To(Succeed())
		})

		By("allowing the user to fill out the login form and submit it", func() {
			Eventually(page.FindByName("email")).Should(BeFound())
			Expect(page.FindByName("email").Fill(AcceptanceSettings("email"))).To(Succeed())
			Expect(page.FindByName("password").Fill(AcceptanceSettings("password"))).To(Succeed())
			Expect(page.FirstByButton("Get Access").Submit()).To(Succeed())
		})

		By("allowing the user to view its data", func() {
			Eventually(page.Find("#user-context")).Should(BeFound())
			Expect(page.Find("#user-context").Click()).To(Succeed())
			Expect(page.Find(".user-submenu")).To(BeVisible())
			Expect(page.Find(".user-submenu .submenu-data p").Text()).To(Equal("Signed in as\nAcceptance Tests"))
		})

		By("allowing the user to logout", func() {
			Eventually(page.Find("#user-context")).Should(BeFound())
			Expect(page.Find("#user-context").Click()).To(Succeed())