Neither of these tests are not doing what they say they are...
They only check that a rule matching the **exact** text specified does/did-not fire (which is obviously very fragile to changes in pp_save_rules.txt in the 'did not' case !!).  
They also don't actually show that the LBVC value was set as expected, just which rules fired.

Effectively, from a unit-test perspective, you eventually need to test the whole call-stack, the levels of which are something like ...
  * 1. iris.save : calls pp.save
  * 2. pp.save : sets up _save_rules, and calls _save_rules.verify
  * 3. verify "calls" rules in 'pp_save_rules.txt' + invokes specific lbfc rule (or not)
  * 4. lbfc rule : accesses \_ff_cross_reference information and sets field.lbfc

The new behaviour introduced, which we need to test, is roughly :
  * new save rule triggers correctly
  * new save rule interprets \_ff_cross_reference data correctly
  * new save rule set LBFC as expected
  * the new data in _ff_cross_reference correctly encodes the (existing) defined translations

(the last one **should** really be covered by existing tests.  But I don't think they exist?)

Obviously, as the new rule is not actually a method, it can't be executed directly, so it can't really be unit-tested and you must use integration tests (in some sense, anyway).
However, I do think we need tests to confirm that (a) it triggers when wanted and (b) the results (lbfc values) are as expected.
The best I could come up with is something like this ...
```
def _pp_save_ppfield_values(cube):
    """
    Emulate saving a cube as PP, and capture the resulting PP field values.

    """
    # Create a test object to stand in for a real PPField.
    pp_field = mock.MagicMock(spec=PPField3)
    # Add minimal content required by the pp.save operation.
    pp_field.HEADER_DEFN = PPField3.HEADER_DEFN
    # Save cube to a dummy file, mocking the internally created PPField
    with mock.patch('iris.fileformats.pp.PPField3',
                    return_value=pp_field):
        target_filelike = mock.Mock(name='target')
        target_filelike.mode = ('b')
        pp_save_call(cube, target_filelike)
    # Return pp-field mock with all the written properties
    return pp_field

class TestLbfcProduction(tests.IrisTest):
    def setUp(self):
        self.cube = stock_make_test_cube()

    def check_cube_stash_yields_lbfc(self, stash, lbfc_expected):
        if stash:
            self.cube.attributes['STASH'] = stash
        lbfc_produced = _pp_save_ppfield_values(self.cube).lbfc
        self.assertEqual(lbfc_produced, lbfc_expected)

    def test_known_stash(self):
        stashcode_str = 'm04s07i002'
        self.assertIn(stashcode_str, STASH_TRANS)
        self.check_cube_stash_yields_lbfc(stashcode_str, 359)

    def test_unknown_stash(self):
        stashcode_str = 'm99s99i999'
        self.assertNotIn(stashcode_str, STASH_TRANS)
        self.check_cube_stash_yields_lbfc(stashcode_str, 0)

    def test_no_stash(self):
        self.assertNotIn('STASH', self.cube.attributes)
        self.check_cube_stash_yields_lbfc(None, 0)
```