Page Object Model testing

In the ongoing process of doing my code work on my Github, I came across an idea that I’d actually encountered before. But it was one for which I’d never previously had an identifying term, and I was excited to learn about this.

Namely, Page Object Model testing. (Not to be confused with Project Object Model, which is what the POM in a pom.xml file stands for when you’re working with Maven.)

What this is: a way of writing a test framework that separates “code that represents the thing you’re testing” from “code that actually does the testing”. Turns out I’d learned about how to do this at Big Fish, when I picked up the idea and how to implement in Python.

Back in those days, it helped to do this because it let me have test cases that basically said “okay go get me the page I need to test, and stick all the data representing it into this object, which I will then do tests against”. It meant that in setup for tests, all I had to do was go grab an instance of the object that represented the page to be tested. And that meant in turn that the tests themselves were more tightly focused.

I found that it required a bit more organizational work to set up, but that once I had the idea in place, it meant writing future tests became easier. For example, if I had test script A that tested the homepage of the site, and then later needed to write test script B against the same page, I wouldn’t have to rewrite the code that loaded the homepage for testing. Likewise, if something about the structure of the homepage changed, I would only have to change the class that dictated that structure, with possibly only minor changes to any test scripts that needed to deal with it.

I liked this way of organizing code well enough that I have been implementing it on my Github repos. In the Python Selenium demo, specifically.

But, now that I’m done with the initial wave of Selenium tests and am looking at ways to expand the suite in both Java and Python, I started thinking of how to rearrange the organizational structure of both suites and seeing whether I could do a similar structure in Java. That led me to discovering that this whole concept had a name.

And it also led me to being able to implement Page Object Model testing in the Java Selenium repo, too.

What this means in practical terms is that I can think of pages on my test WordPress site in terms of “here is an object that represents an entire page, including child objects”. These child objects would be things that are shared across all pages, like a sidebar, or a footer, or a menu. Their various objects are things I have to implement only once in a Page Object Model system, and then use as necessary in tests that actually look at them on different pages.

So all in all this has been a satisfying area of research.

Some links I’ve used to read up about this:

Page Object Model (POM) | Design Pattern on Medium.com

Getting Started with Page Object Pattern for Your Selenium Tests on Pluralsight.com

Coding projects update

As of this writing, I now have a total of five repositories on my Github account: the misc-configs repo for various config/supplementary files, and two each for Java and Python work. For each of those languages, I have a repo for the REST API portion of this project, and one for the Selenium.

All of the repos can be seen on my Github account.

What I’ve been calling the rough “phase 1” of this project is now more or less complete. I’ve got basic test cases in place in both languages for both the REST API side, and the Selenium side. As I’ve written about before, the API tests are dealing with the service endpoints that handle publicly viewable information. The Selenium tests are mostly oriented around testing parts of the homepage of my little test WordPress site.

Now I’m moving into the rough “phase 2”. In this phase, I’m adding more Selenium tests. This’ll include adding some sidebar tests for the homepage, as well as tests for additional sections of the site (a post and a page), and making sure that the elements are correct on the selected links. I’ll also be testing site search and adding a new comment to a previously existing post, since that’s something I can do without authentication.

“Phase 3” of this project will get into dealing with stuff that requires authentication. From the REST API side, this’ll mean dealing with the service endpoints that handle things at the site admin level (such as making a new post or comment, or editing a previously existing one). From the Selenium side, I’ll want to see about verifying logging in and logging out of the site, and making sure that the links displayed in the “META” area of the sidebar update themselves accordingly.

(NOTE: I am NOT going to try to test the actual WordPress admin UI. That’s a whole different kettle of fish than testing a front-facing site.)

In related news, I’ve also discovered the Githubs “Projects” functionality, and I’ve made myself a project there to cover the work I’m doing. This amuses me, as their Projects board looks a lot like JIRA, the bug tracking/project management software we used at my Former Day Job, as well as at the short contract I had after the layoff at the tail end of last year.

Interested parties can find my current active project on my Github projects page. I’ll be adding additional projects to that once this one is complete–like the WordPress plugin work I want to do!

I’ve actually had job recruiters and interviewers ask me about this work, now that I’ve got a link to my Github on my resume. This has proven beneficial in interviews I had last week, and I even got useful tips on additional libraries I can research, as well as aspects of version 8 of Java I hadn’t had experience with yet. I’ve gotten positive feedback about how I do comments on things, as well as on the various Readmes I’ve put on the repos.

So while the work hasn’t yet actually proven critical in landing me a job, it has proven useful in helping me demonstrate that I not only know how to code, but that I like it well enough to do it on my own time and to plan out larger projects.

This is, I feel, a very valuable thing for me to be able to demonstrate.

Coding projects update

I now have three active repositories up on my Github account. These are:

misc-configs: This one is for miscellaneous config files that are useful for the tests in the other repositories. What’s in here will mostly make sense to you if you are familiar with a) how to import data into a WordPress site, b) how to import Collections or Environment files into Postman, and/or c) how to use a YAML file to run Docker Compose to launch one or more containers.

wp-test-demo-java: This one is for my demo of testing the REST API endpoints made available by WordPress for any given site. Phase 1 of the work on this demo is complete, in which I test against the endpoints that handle publicly accessible data. I.e., the kinds of things you could find out about a WordPress site if you’re just a visitor to the site.

wp-test-demo-java-selenium: This demo is also using my test WordPress site, but here, I am doing front end testing rather than service testing. I’m using the Selenide Java library to run tests against the site via Selenium, a widely used automation framework for testing web pages. Selenide is a layer on top of Selenium that does the heavy lifting of Selenium setup for me, and frees me up to focus on the test cases I want to run.

This is a work in progress, but as of this post it has 27 test cases in it. There are more to come.

Other projects that’ll be showing up on my Github account include:

  • Phase 2 of the REST API project, which would involve hitting service endpoints that specifically require authentication.
  • Porting the Selenium tests over into Python, and structuring them in such a way as to be similar to the Python test framework we used on my former team at Big Fish. The intent here would be to demonstrate my ability to use Selenium in Python, and to write up a framework for it. (Which will require more work than the equivalent testing in Java!)
  • The teeny WordPress plugin I want to do that’ll make nice Dreamwidth-style user and community name tags in a post or page for me. (This is the one I’ve mentioned before that would be an expansion on the very old plugin that does this for LJ user and community tags.) This would be written in PHP, and the intent HERE would be to show my comfort level with PHP. I haven’t used this language as much in a professional context, but I HAVE used it a lot over the years dealing with my websites, and I can demonstrate that here.

Stretch goals:

  • Do something in JavaScript. What, I don’t know yet, but the obvious possibility would be to port some or all of the previously mentioned Selenium tests.
  • Since I do have a locally running plugin on annathepiper.org that fuels my Roleplay Logs page, time permitting, I’d like to do a more solid version of that. Right now the plugin I’m running is a hack of the previous non-Wordpress-based code, and it talks to a database outside the WordPress structure. A cleaner version of this would actually be properly integrated with WordPress. If I get really fancy, I could do an entry form in the Admin UI for WordPress to allow the addition of new logs, and possibly even reading them in via the Media section of the site. This would, of course, also be written in PHP. More on this as events warrant!

Today’s WordPress Test Demo update

Good progress on the coding project today! \0/ Things accomplished:

  • Added new test cases involving Categories, Tags, Pages, and Comments, to bring the total number of test cases up to 10
  • Added the ability to run the cases via a Maven configuration as well as TestNG, and updated my pom.xml to use the testng.xml as its suite file
  • Checked all the new test cases and related work into wp-test-demo-java
  • Renamed my wordpress-dev repo to misc-configs, because that’s really what it’s for miscellaneous config files
  • Updated my Postman collection to include all the endpoints for the test cases I wrote today, and checked the new version of that into misc-configs
  • Updated the Readmes on both wp-test-demo-java and misc-configs to more clearly explain what the repos are for, particularly wp-test-demo-java, as I’ll be pointing recruiters at that
  • Installed Jenkins (again) on my dev laptop, so that I can run the automation as a local Jenkins job as well as within IntelliJ, and to keep up my practice using Jenkins

I have decided, too, that I’ll be doing this project in phases.

Phase 1: REST API tests that hit the endpoints that can serve up publicly available data. I.e., the kinds of data you’d see as a user just browsing a WordPress site.

Phase 2: Selenium-based tests that will do front-end type tests. For example, “If I click on this link, does it take me to this expected target page?” Or, “If I click on this thing on the menu, do I get the correct dropdown off of it?”

Phase 3: This is the ambitious part. There are also REST API endpoints for WordPress that’ll let you get at the stuff you’d ONLY see as an authenticated user, such as post revisions and settings and the like. Time permitting, I may learn about the various ways to actually do that authentication properly so that the test suite can actually get at those endpoints.

Right now, though, I’m going to focus on phases 1 and 2.

The WordPress testing demo project is now underway

Spent most of today (very roughly during ‘work’ hours, just to try to keep to the whole idea of coding to a schedule) working on the WordPress testing demo project I talked about in my last post. As of this writing, I have some actual working things checked in up on Github. There’s only one functional test case so far, but it’s a start!

What I accomplished today:

  • Creating a Github repo for this work
  • Read about the API endpoints that WordPress makes available for any given site, some of which are publicly viewable, others of which require you to log in as a valid user
  • Started a Postman Collection to keep track of the endpoints I’ll be playing with for my test site, and checked an initial version of this in on Github
  • Refreshed my memory about how Unirest works, as this was the library we used at Big Fish to talk to various services; maybe not the most current library to use, but it’s the one I know, so I’m going with this for demo purposes
  • Got IntelliJ on the Linux partition of my dev laptop updated to the latest version
  • Built the actual project in IntelliJ, as a Maven project, so it’d have the correct file structure and a pom.xml file I could add dependencies to
  • Started building a client class that will use Unirest to hit those endpoints for my local test site
  • Built a BaseTest class in charge of doing setup used by all the test classes I’ll be making
  • Built a TestPosts class to start the test cases for the “Posts” endpoints in the aforementioned API, and now it even has an initial functional test case!

Now that I have an actual working (if tiny) framework here, I should be able to fill in some test cases reasonably quickly.

Note also that the test suite assumes I am running the WordPress test site locally. For bonus usefulness I should make some sort of healthcheck test case that verifies that the test site is in fact UP.

Further planning for doing my coding demo project

Since I continue to have time on my hands and no active leads bringing me in for interviews this coming week (so far), I’m moving forward with laying down the plans for my coding demo.

As I said in my last post about this (here for those of you reading on Dreamwidth), I’ve succeeded in setting up a test WordPress site in Docker.

The rest of this operation is going to look something like this, at least for phase 1 of this project:

  • Actually get some content into that test WordPress site. This will probably involve just doing a database copy down from my backup WordPress site up on angelahighland.wordpress.com. If for some reason I can’t do that, I’ll install a lorem ipsum generator plugin (there are a few for WordPress, I looked) and generate purely random content.
  • Study up on the REST API WordPress makes available for any given install.
  • Once I know what service endpoints are available, use that to scope out what test cases I can do.
  • Write out those test cases in a Java BVT suite, similar to the ones I wrote at Big Fish. Tools I will need for this: IntelliJ, TestNG.

A possible Phase 2 for this project will involve extending the testing to include front-end testing. In other words (for those of you unfamiliar with how web testing works), hitting the pages of the test site in a browser and verifying that expected things are there, and/or that you are able to do certain things (e.g., log in, do a search, leave a comment). Tools I will need for this: Selenium (also in a Docker image), with a side helping of the Selenide framework. This would be a followup on my previous research that I did as one of my last projects at Big Fish.

Possible stretch goal: replicate some of the same test cases in Python, just to brush up on my Python skills. Tools I’d be using in this part of the work: PyCharm.

I’ve been writing out some tasks for myself in Things, by way of a task breakdown, and I suppose this blog post kind of counts as a spec. Ha. :D

And when I’ve got some actual code, I’ll be checking it in on my personal Github account. This will be fun, hopefully, as well as a way to keep my skills active until such time as I can convince somebody to give me another job!

(EDITING TO ADD: This, by the way, is a separate project I’m planning in addition to doing a WordPress plugin! So I’ll have multiple things I can eventually point at by way of demonstrating I can code. What I’m talking about in this post is more along the lines of demonstrating something similar to the last code I wrote at Big Fish.)