Apply suggestions from code review

Co-authored-by: Matthew Burket <m@tthewburket.com>

Author: jan-cerny

_posts/2022-10-24-xmldiff-unit-tests.md

@@ -11,9 +11,9 @@ Recently, we have decided to improve the test coverage of the [ComplianceAsCode]
 Specifically, we have focused on testing code that works with XML.
 We have been creating tests for methods that generate XML elements or generate XML trees or transform one XML tree to another.
 
-At the first sight, testing these types of methods looks easy.
-We have created some fixtures and then we have written some test cases with asserts counting the amount of generated elements and attributes and checking the expected values.
-That looked like in this example:
+At first sight, testing these types of methods looks easy.
+We created some fixtures and then wrote some test cases with asserts counting the amount of generated elements and attributes and checking the expected values.
+An example of this is below:
 
 ```python
 def test_group_to_xml_element(group_selinux):
@@ -26,12 +26,12 @@ def test_group_to_xml_element(group_selinux):
     ... snip ...
 ```
 
-This is quite easy and most of the people would be fine with a test case like this.
+This is quite easy and most people would be fine with a test case like this.
 The advantage of this approach was that every requirement on the tested method had its own assert so when test started to fail it was immediately obvious what is broken.
 However, we didn't quite like it.
 The expected XML structure generated by the tested method (`to_xml_element()` in the example above) isn't clear from the code.
 The test can be quite long and it is laborious to write all the asserts for methods generating big XML trees with many child elements.
-So we have started to look for options of improving the tests.
+So we have started to look for options for improving the tests.
 
 ## Get familiar with xmldiff
 
@@ -56,7 +56,7 @@ $ xmldiff file1.xml file2.xml
 
 The `xmldiff` command will return a list of actions.
 This list of actions is so-called "Edit Script" and contains all changes needed to transform the first compared XML to the second compared XML.
-In the example above, we can see there are 2 differences between the 2 XML files.
+In the example above, we can see there are two differences between the two XML files.
 First is that the attribute `idref` on element described by XPath expression `/ns0:Rule/ns0:platform[1]` is changed to `virtual`.
 Second is that the text of the element described by XPath expression `/ns0:Rule/ns0:ident[1]` is changed to `777777`.
 
@@ -68,7 +68,7 @@ diff = xmldiff.main.diff_files("file1.xml","file2.xml")
 print(diff)
 ```
 
-It seems that the `xmldiff` is very easy to be used so we have decided to use it in our unit tests.
+It seems that the `xmldiff` is very easy to use, so we have decided to use it in our unit tests.
 The [xmldiff documentation](https://xmldiff.readthedocs.io/en/stable/) is a good starting point.
 
 But, we have encountered some small caveats, which we will describe below.
@@ -94,15 +94,15 @@ def test_group_to_xml_element(group_selinux, group_selinux_xml):
 
 ## Handling white space
 
-However, then we reviewed our code and we kind of didn't like the saved XML test data -- they were ugly, with no nice formatting.
-So we naturally decided to apply `xmllint` pretty format and then the XMLs look pretty.
+However, then we reviewed our code and we didn't like the saved XML test data — they were ugly, with no nice formatting.
+So we decided to apply `xmllint` pretty format and then the XMLs look pretty.
 But, the tests started to fail.
 
-We have found that the `xmldiff` is very sensitive produced a bunch of differences that we add newline and whitespace here and there.
+We have found that the `xmldiff` is very sensitive and produced a bunch of differences that we add newline and whitespace here and there.
 We were wondering how to convince `xmldiff` to ignore the whitespace.
-We didn't want to run `xmllint` command as a sub process in our tests.
+We didn't want to run `xmllint` command as a subprocess in our tests.
 We tried to use [formatters](https://xmldiff.readthedocs.io/en/stable/api.html#using-formatters) but with no luck, xmllint still behaved sensitively to whitespace.
-We were mainly concerned that the data in the form they are stored are will be difficult to review and the whitespace sensitivity will make them cumbersome to maintain.
+We were mainly concerned that the data in the stored form would be difficult to review and the whitespace sensitivity would make them cumbersome to maintain.
 By accident, we have discovered that this behavior doesn't happen with the `xmllint.main.diff_files()` method.
 That method isn't sensitive to whitespace or formatting of the XML files, so we can save them in a pretty format.
 So we reworked our tests so that the test first saved the output of the tested method to a temporary file and then we called `xmllint.main.diff_files()` to compare this temporary file with our static file in test data.
@@ -123,8 +123,8 @@ Note: The `temporary_filename` is a context manager that gives us a temporary fi
 
 ## Working with namespaces
 
-One of our methods transforms a given XML tree to a different XML tree that differs in a couple of attributes and values but rest of the tree is the same.
-So we have compared the input of this method with the output of this method using `xmldiff` and we got the diff in a form of an Edit script.
+One of our methods transforms a given XML tree to a different XML tree that differs in a couple of attributes and values but the rest of the tree is the same.
+So we have compared the input of this method with the output of this method using `xmldiff` and we got the diff in the form of an Edit script.
 Then, we had to solve how to write an assert that this Edit script is the expected one.
 In other words, to verify that the `xmldiff` has given the expected diff.
 We found that the items in the diff are Python `namedtuple`s and that we can easily create our own `namedtuple`s in the code and then check if they're present in the diff.
@@ -162,9 +162,9 @@ def test_foo(old, new):
 
 Another problem that we faced is that we wanted to use the `xmldiff` tests in our upstream and downstream CI.
 Unfortunately, we discovered that the library isn't available as RPM, neither in Fedora nor in RHEL.
-It's available only in PyPi.
+It's available only in PyPI.
 That means we can't execute the tests in some of our test environments.
-But, we wanted to still run the tests in the environments where `xmldiff` is available and at the same time not disable all the unit tests on the other systems. Fortunately, `pytest` has a very elegant method `importorskip()` that makes the test case be skipped when some module isn't available and still runs the other test cases.
+But, we wanted to still run the tests in the environments where `xmldiff` is available and at the same time not disable all the unit tests on the other systems. Fortunately, `pytest` has a very elegant method `importorskip()` that skips the test case when some module isn't available and still runs the other test cases.
 
 We have used this method in every test function where we use `xmldiff`: