Symbiont is my open source test framework, distributed under the MIT license. This post will provide a quick tutorial on how you can evolve your script from a pure watir-webdriver implementation to one that is driven by Symbiont.
The Rules of Inform 7
In this post, I’ll continue on the exploration of Inform 7 that I started in the introductory post. Here I’ll continue to add to the game source text started in that post, putting emphasis on rules. Rules are one of the keys aspects — the other being actions — of how Inform 7 allows authors to interact with their game players.
Introduction to Inform 7
In a series of posts, I’ll be writing about a gaming system I’ve been using to teach children writing skills but have also found helps testers with analysis and thinking skills. This particular gaming system is called Inform 7 and it’s used to program interactive fiction games, which used to be called “text adventures” back in the day. Inform 7 offers some unique challenges to thinking, writing, and programming such that I’ve found it to be an excellent system to explore with. Given that Inform 7 is used to create games that present puzzles to be solved, it’s been instructive for me to treat Inform 7 itself as a puzzle to be solved.
An Introduction to Using Cucumber-JVM
A lot of testers I run into learn Cucumber on Ruby. This tends to be a very easy path since the overhead on a dynamic language like Ruby is generally pretty low. However, some testers need or want to run Cucumber on the Java Virtual Machine. Yes, you can use JRuby to run the Ruby version of Cucumber on the JVM. But you can also use Cucumber-JVM, which is a port of the Ruby version into Java. However, I find many testers have a hard time getting started with it, particularly if they are coming from Ruby. What follows is the tutorial I wanted and either didn’t find or didn’t look hard enough to find.
Data Building with Symbiont
In the previous post in data setting, I talked about the start of a data builder pattern. Sometimes it’s nice to have your automation use descriptive phrases that stand in for specific bits of data. So here I’ll describe how Symbiont allows this by adhering to a data builder pattern.
Data Setting with Symbiont
In this post, I’ll explore how I’m starting to provide a data builder pattern with Symbiont. The specific focus is on how you supply data to page definitions as part of your automated test logic.
Path Testing: Independent Paths
This post follows on from the previous two in this series (theory and path coverage). A key theme of these posts is that of modeling paths through an application and then using tests to exercise those paths. What we’ve seen so far is that while many path segments are covered repeatedly, others may only be touched once. You most likely won’t have time to test them all. Along with that, some paths will be more data-dependent than others. So a selection process is critical. Here I’ll talk more about that selection process.
Multiple Versions of Python on Windows
A lot of testers like to use Python. A lot of testers are on Windows machines. There is currently a large gap in the Python world between the 2.x and 3.x branch. (See more details on this.) This often puts testers in the position of having to make Python solutions that run on both versions. But, on Windows at least, this has been tricky in terms of having two Python versions installed and easily moving between them. Here I’ll talk about how the Python development team has eased this with the Windows launcher.
Path Testing: The Coverage
This post continues on from discussing the theory around path testing. Now I want to put some of that theory into practice. While this is geared toward testing, it by necessity jumps into the programmatic side of things. I think this is an important view for testers to have.
Path Testing: The Theory
Path analysis is often considered an activity that is done only by developers. In fact, path analysis is a technique that can be used by both developers and testers. I find many testers, however, who are unaware of this test technique or are uncertain of how to best apply it. So let’s talk about it.
Quality Is As Quality Does
The notion of a “QA team” can set up unrealistic expectations about who “mandates” quality and who is “responsible” for quality. We know quality by indirect means of how things function or provide value; not as a result of the actions of a team. Does that sound silly? Let’s talk about it.
Symbiont and the Context Factory
In the post on using page objects with Symbiont, the focus was on how Symbiont leverages the page object to allow test scripts to separate intent from implementation. This also allowed for test script logic to be concise in terms of its expression. Here I’m going to focus on how we can get even slightly more concise by adhering to a factory pattern.
Symbiont and the Page Object
In the post on going from Watir to Symbiont, I talked about how Symbiont encourages you to delegate as much as possible to the page definition. The reason for this being that page definitions get turned into page objects, thus allowing your scripts to rely on the page object to handle functionality, rather than having each automated script do so. Here I’ll explore that idea a bit more.
From Watir to Symbiont
Encouraged a bit after the fact by a Ruby test framework in 15 minutes, along with my own post on a slimmed down Ruby test framework, and coupled with my Dialect experiment, I reworked an existing framework of mine (Symbiont) from another framework of mine (Fluent). Here I’ll explain how to get started with Symbiont.
Starting a Rails App, Part 2
This is the second, and final, post in the series about starting off on a Rails application. In the first post the basis for a “Planets” application was created. I ended up with a database (model) and a functioning mechanism around that database that let me create, edit, and delete records (views). All of that was knitted together into a working application by a controller. However, those views have no validation on them. That means the database is not protected from bad data. I’ll fix that here and then focus a lot on how Rails apps are tested.
Starting a Rails App, Part 1
Many testers these days will find themselves in Rails shops and, even if that’s not the case, Rails is a good environment within which to build custom test solutions that require a database and a web interface. This is largely because when using Rails, you are using one of the most concise and expressive languages out there: Ruby. I plan to document some of my learning of the Rails ecosystem in two posts.
The Craft of Testing
Being a tester with an avid interest (and some practice) in fiction writing, I liken the craft of testing to the craft of writing fiction particularly because I found some correlations in terms of writing fiction and writing tests. (Oh, the opportunities for a few jokes there.) The focus I’m going to be building on here is really a similarity of craft or, more accurately, how there are similar thinking styles that translate between crafts.
Learning the Rails Way – A Tester’s Perspective
In a previous post I talked about learning Rails in a way that I wished it had been presented to me. Here I’ll focus a little on the salient facts about the framework that you will no doubt find elsewhere, but sometimes you have to distill it from surrounding material that gets in the way. Near the end, I’ll explain why any of this has relevance to me writing as a tester.
Continue reading Learning the Rails Way – A Tester’s Perspective
A Tester Learns Rails
I played around with Node.js in a previous post for web framework design. Now I want to explore Rails a bit. I haven’t found tutorials that I really like on Rails, at least for those getting started. Now that I have gotten started, some of those tutorials I did find are more helpful to me, but they weren’t as helpful starting out. So here I’ll write in a way that helped me learn more about how Rails is actually working, rather than just relying on the “magic” that everyone tells me is happening behind the scenes.
The Dialect Diary — Symbiont Reborn!
I have spent the better part of the last five years learning how to design effective and efficient test frameworks and libraries. I may actually be making progress. This post will detail a bit of why and show how the Dialect project has evolved into a radically new life form, albeit one that did exist before.