Adam.S
Posted on May 26, 2021
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.
Qualifier
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.
Definition
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.
Testing
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
MechanismKind
I took the same approach here with MechanismKind.
Definition
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"
}
}
}
Testing
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),
]
}
asMechanism
Here I would refer you to the documentation on Strings and Characters.
Code
I have updated struct Mechanism as shown below
struct Mechanims {
--snip--
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;
}
--snip--
}
Tests
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: "192.168.1.0/24");
XCTAssertEqual(Mech.asMechanism(), "ip4:192.168.1.0/24");
}
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.
Closing
Today I implemented an initial get() function for both Qualifier and MechanismKind. I also did an initial implementation for asMechanism().
Posted on May 26, 2021
Join Our Newsletter. No Spam, Only the good stuff.
Sign up to receive the latest update from our blog.