Swift: Deconstruct SPF - Qualifier and MechanismKind

Learning Swift: Enum

In this article I will be looking at defining the enums for Qualifier and MechanismKind. I will also be adding tests to ensure that the functions work as expected. Further I will implement a simple asMechanism() as a proof of concept.


As mentioned in an earlier article. The Qualifier will consist of the following values.

  • + Pass
  • - Fail
  • ~ SoftFail
  • ? Neutral
  • None

I expect that I will want to be able to obtain the character value (rawValue) at some point in the future.


enum Qualifier: String {
    case Pass
    case Fail
    case SoftFail
    case Neutral
    case None
    func get() -> String {
        switch self {
        case .Pass:
            return "+"
        case .Fail:
            return "-"
        case .SoftFail:
            return "~"
        case .Neutral:
            return "?"
        case .None:
            return ""

At this point I have diverged from the original definition. This gave me a chance to look at the switch statement in Swift. I think will change this in a refactor session, as I expect to be able to access the Raw Value. Scroll down to find the actual documentation.


To make testing a little cleaner and manageable moving forward. I also created a new file under DeconfSpfTests called DeconfSpfQualifierTests.swift.

This contains the following code.

import XCTest
@testable import DeconSpf;

final class SPFQualifierTests: XCTestCase {

    func testQualifierPass() {
        let Q = Qualifier.Pass;
        XCTAssertEqual(Q.get(), "+");
    func testQualifierFail() {
        let Q = Qualifier.Fail;
        XCTAssertEqual(Q.get(), "-");
    func testQualifierSoftFail() {
        let Q = Qualifier.SoftFail;
        XCTAssertEqual(Q.get(), "~");
    func testQualifierNeutral() {
        let Q = Qualifier.Neutral;
        XCTAssertEqual(Q.get(), "?");
    func testQualifierNone() {
        let Q = Qualifier.None;
        XCTAssertEqual(Q.get(), "");

    static var allTests = [
        ("testQualifierPass", testQualifierPass),
        ("testQualifierFail", testQualifierFail),
        ("testQualifierSoftFail", testQualifierSoftFail),
        ("testQualifierNeutral", testQualifierNeutral),
        ("testQualifierNone", testQualifierNone),

  • Note: The class name needs to be unique
    • final class SPFQualifierTests: XCTestCase
    • I am using SPFQualifierTests


I took the same approach here with MechanismKind.


enum MechanismKind {
    case Redirect, Include, A, MX, ip4, ip6, All;
    func get() -> String {
        switch self {
        case .Redirect:
            return "redirect="
        case .Include:
            return "include:"
        case .A:
            return "a"
        case .MX:
            return "mx"
        case .ip4:
            return "ip4:"
        case .ip6:
            return "ip6:"
        case .All:
            return "all"


I also again created a new test file called DeconfSpfMechanismKindTests.
This also has a unique class name SPFMechanimsKindTests.

import XCTest
@testable import DeconSpf;

final class SPFMechanimsKindTests: XCTestCase {

    func testMechanimsKindRedirect() {
        let MK = MechanismKind.Redirect;
        XCTAssertEqual(MK.get(), "redirect=");
    func testMechanimsKindInclude() {
        let MK = MechanismKind.Include;
        XCTAssertEqual(MK.get(), "include:");
    func testMechanimsKindA() {
        let MK = MechanismKind.A;
        XCTAssertEqual(MK.get(), "a");
    func testMechanimsKindMX() {
        let MK = MechanismKind.MX;
        XCTAssertEqual(MK.get(), "mx");
    func testMechanimsKindIp4() {
        let MK = MechanismKind.ip4;
        XCTAssertEqual(MK.get(), "ip4:");
    func testMechanimsKindIp6() {
        let MK = MechanismKind.ip6;
        XCTAssertEqual(MK.get(), "ip6:");
    func testMechanimsKindAll() {
        let MK = MechanismKind.All;
        XCTAssertEqual(MK.get(), "all");

    static var allTests = [
        ("testMechanismKindRedirect", testMechanimsKindRedirect),
        ("testMechanismKindInclude", testMechanimsKindInclude),
        ("testMechanismKindA", testMechanimsKindA),
        ("testMechanismKindMX", testMechanimsKindMX),
        ("testMechanismKindIp4", testMechanimsKindIp4),
        ("testMechanismKindIp6", testMechanimsKindIp6),
        ("testMechanismKindAll", testMechanimsKindAll),



Here I would refer you to the documentation on Strings and Characters.


I have updated struct Mechanism as shown below

struct Mechanims {
  func asMechanism() -> String {
      var mechanismString = String();
      // TODO: Qualifier
      // Access the string for this mechanism's kind.
      mechanismString += self.kind.get();
      // Access the string for the mechanim
      mechanismString += self.mechanism;
      return mechanismString;


I now have my previous test working as well as a few new ones.

func testAsMechanismIp4() {
    let Mech = Mechanism(k: MechanismKind.ip4, q: Qualifier.None, m: "");
    XCTAssertEqual(Mech.asMechanism(), "ip4:");
func testAsMechanismIp6() {
    let Mech = Mechanism(k: MechanismKind.ip6, q: Qualifier.None, m: "X:X:X:X/16");
    XCTAssertEqual(Mech.asMechanism(), "ip6:X:X:X:X/16");
func testAsMechanismRedirect() {
    let Mech = Mechanism(k: MechanismKind.Redirect, q: Qualifier.None, m: "_spf.example.com");
    XCTAssertEqual(Mech.asMechanism(), "redirect=_spf.example.com");
func testAsMechanismInclude() {
    let Mech = Mechanism(k: MechanismKind.Include, q: Qualifier.None, m: "_spf1.example.com");
    XCTAssertEqual(Mech.asMechanism(), "include:_spf1.example.com");
func testAsMechanismA() {
    let Mech = Mechanism(k: MechanismKind.A, q: Qualifier.None, m: "");
    XCTAssertEqual(Mech.asMechanism(), "a");
func testAsMechanismMx() {
    let Mech = Mechanism(k: MechanismKind.MX, q: Qualifier.None, m: "");
    XCTAssertEqual(Mech.asMechanism(), "mx");

Note that these tests are not complete. And do not yet cover all cases. In particular these tests will fail with several examples of A and MX Mechanisms.

The code for this project can now be found here.

This is the diff between Initial and Initial-asMechanism.


Today I implemented an initial get() function for both Qualifier and MechanismKind. I also did an initial implementation for asMechanism().

See also