Swift: SPF 분해: Qualifier 및 MechanismKind

이 기사에서는 Qualifier 및 MechanismKind 에 대한 열거형을 정의하는 방법을 살펴보겠습니다. 또한 기능이 예상대로 작동하는지 확인하기 위해 테스트를 추가할 것입니다. 또한 개념 증명으로 간단한asMechanism()을 구현할 것입니다.

예선

이전 기사에서 언급했듯이. 한정자는 다음 값으로 구성됩니다.

+ 패스

- 실패

~ 소프트페일

? 중립

없음

나는 문자 값(rawValue)을 얻을 수 있기를 원할 것이라고 기대합니다.
미래의 어느 시점에서.

정의

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 ""
        }
    }
}

이 시점에서 나는 원래의 정의에서 벗어났습니다. 이것은 나에게 Swift의 switch 문을 볼 기회를 주었습니다. Raw Value 에 액세스할 수 있을 것으로 예상되므로 리팩터 세션에서 이것을 변경할 것이라고 생각합니다. 아래로 스크롤하여 실제 문서를 찾습니다.

테스트

테스트를 좀 더 깔끔하고 관리하기 쉽게 하기 위해. 또한 DeconfSpfTests 아래에 DeconfSpfQualifierTests.swift 라는 새 파일을 만들었습니다.

여기에는 다음 코드가 포함되어 있습니다.

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),

    ]
}

참고: 클래스 이름은 고유해야 합니다.

final class SPFQualifierTests: XCTestCase

사용하고 있습니다 SPFQualifierTests

메커니즘 종류

나는 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"
        }
    }
}

테스트

또한 DeconfSpfMechanismKindTests 라는 새 테스트 파일을 다시 만들었습니다.
이것은 또한 고유한 클래스 이름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),

    ]
}

as메커니즘

여기에서 Strings and Characters 에 대한 문서를 참조하겠습니다.

암호

아래와 같이 업데이트struct Mechanism 했습니다.

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--
}

테스트

이제 이전 테스트와 몇 가지 새로운 테스트가 작동합니다.

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");
}

이러한 테스트는 완료되지 않았습니다. 그리고 아직 모든 경우를 다루지는 않습니다. 특히 이러한 테스트는 A 및 MX 메커니즘의 여러 예에서 실패합니다.

이제 이 프로젝트의 코드를 찾을 수 있습니다here.

이것은 Initial과 Initial-asMechanism 사이의 diff입니다.

폐쇄

오늘 저는 get() 와 Qualifier 둘 다에 대해 초기 MechanismKind 함수를 구현했습니다. 또한 asMechanism() 에 대한 초기 구현을 수행했습니다.