diff --git a/Sources/JSONAPIOpenAPI/Sampleable/Include+Sampleable.swift b/Sources/JSONAPIOpenAPI/Sampleable/Include+Sampleable.swift new file mode 100644 index 0000000..895e561 --- /dev/null +++ b/Sources/JSONAPIOpenAPI/Sampleable/Include+Sampleable.swift @@ -0,0 +1,184 @@ +// +// Include+Sampleable.swift +// JSONAPIOpenAPI +// +// Created by Mathew Polzin on 1/23/19. +// + +import JSONAPI + +extension Includes: Sampleable where I: Sampleable { + public static var sample: Includes { + guard I.self != NoIncludes.self else { + return .none + } + + return .init(values: I.samples) + } +} + +extension NoIncludes: Sampleable { + public static var sample: NoIncludes { + return NoIncludes() + } +} + +extension Include1: Sampleable where A: Sampleable { + public static var sample: Include1 { + return .init(A.sample) + } + + public static var samples: [Include1] { + return A.samples.map(Include1.init) + } +} + +extension Include2: Sampleable where A: Sampleable, B: Sampleable { + public static var sample: Include2 { + let randomChoice = Int.random(in: 0..] { + return A.samples.map(Include2.init) + + B.samples.map(Include2.init) + } +} + +extension Include3: Sampleable where A: Sampleable, B: Sampleable, C: Sampleable { + public static var sample: Include3 { + let randomChoice = Int.random(in: 0..] { + return A.samples.map(Include3.init) + + B.samples.map(Include3.init) + + C.samples.map(Include3.init) + } +} + +extension Include4: Sampleable where A: Sampleable, B: Sampleable, C: Sampleable, D: Sampleable { + public static var sample: Include4 { + let randomChoice = Int.random(in: 0..] { + return A.samples.map(Include4.init) + + B.samples.map(Include4.init) + + C.samples.map(Include4.init) + + D.samples.map(Include4.init) + } +} + +extension Include5: Sampleable where A: Sampleable, B: Sampleable, C: Sampleable, D: Sampleable, E: Sampleable { + public static var sample: Include5 { + let randomChoice = Int.random(in: 0..] { + let set1: [Include5] = A.samples.map(Include5.init) + + B.samples.map(Include5.init) + + C.samples.map(Include5.init) + + let set2: [Include5] = D.samples.map(Include5.init) + + E.samples.map(Include5.init) + + return set1 + set2 + } +} + +extension Include6: Sampleable where A: Sampleable, B: Sampleable, C: Sampleable, D: Sampleable, E: Sampleable, F: Sampleable { + public static var sample: Include6 { + let randomChoice = Int.random(in: 0..] { + let set1: [Include6] = A.samples.map(Include6.init) + + B.samples.map(Include6.init) + + C.samples.map(Include6.init) + + let set2: [Include6] = D.samples.map(Include6.init) + + E.samples.map(Include6.init) + + F.samples.map(Include6.init) + + return set1 + set2 + } +} + +extension Include7: Sampleable where A: Sampleable, B: Sampleable, C: Sampleable, D: Sampleable, E: Sampleable, F: Sampleable, G: Sampleable { + public static var sample: Include7 { + let randomChoice = Int.random(in: 0..] { + let set1: [Include7] = A.samples.map(Include7.init) + + B.samples.map(Include7.init) + + C.samples.map(Include7.init) + + let set2: [Include7] = D.samples.map(Include7.init) + + E.samples.map(Include7.init) + + F.samples.map(Include7.init) + + let set3: [Include7] = G.samples.map(Include7.init) + + return set1 + set2 + set3 + } +} + +extension Include8: Sampleable where A: Sampleable, B: Sampleable, C: Sampleable, D: Sampleable, E: Sampleable, F: Sampleable, G: Sampleable, H: Sampleable { + public static var sample: Include8 { + let randomChoice = Int.random(in: 0..] { + let set1: [Include8] = A.samples.map(Include8.init) + + B.samples.map(Include8.init) + + C.samples.map(Include8.init) + + let set2: [Include8] = D.samples.map(Include8.init) + + E.samples.map(Include8.init) + + F.samples.map(Include8.init) + + let set3: [Include8] = G.samples.map(Include8.init) + + H.samples.map(Include8.init) + + return set1 + set2 + set3 + } +} + +extension Include9: Sampleable where A: Sampleable, B: Sampleable, C: Sampleable, D: Sampleable, E: Sampleable, F: Sampleable, G: Sampleable, H: Sampleable, I: Sampleable { + public static var sample: Include9 { + let randomChoice = Int.random(in: 0..] { + let set1: [Include9] = A.samples.map(Include9.init) + + B.samples.map(Include9.init) + + C.samples.map(Include9.init) + + let set2: [Include9] = D.samples.map(Include9.init) + + E.samples.map(Include9.init) + + F.samples.map(Include9.init) + + let set3: [Include9] = G.samples.map(Include9.init) + + H.samples.map(Include9.init) + + I.samples.map(Include9.init) + + return set1 + set2 + set3 + } +} diff --git a/Sources/JSONAPIOpenAPI/Sampleable.swift b/Sources/JSONAPIOpenAPI/Sampleable/Sampleable.swift similarity index 84% rename from Sources/JSONAPIOpenAPI/Sampleable.swift rename to Sources/JSONAPIOpenAPI/Sampleable/Sampleable.swift index c730791..0e8fe58 100644 --- a/Sources/JSONAPIOpenAPI/Sampleable.swift +++ b/Sources/JSONAPIOpenAPI/Sampleable/Sampleable.swift @@ -18,17 +18,33 @@ public protocol Sampleable { /// Get an example of success, if that is meaningful and /// available. If not, will be nil. + /// + /// The default implementation returns `nil`. static var successSample: Self? { get } /// Get an example of failure, if that is meaningful and /// available. If not, will be nil. + /// + /// The default implementation returns `nil`. static var failureSample: Self? { get } + + /// An array of samples of this Type. + /// + /// The default implementation returns + /// an array with just the result of + /// `Self.sample` in it. + static var samples: [Self] { get } } public extension Sampleable { + // default implementation: public static var successSample: Self? { return nil } + // default implementation: public static var failureSample: Self? { return nil } + + // default implementation: + public static var samples: [Self] { return [Self.sample] } } extension Sampleable { @@ -114,3 +130,9 @@ extension NoLinks: Sampleable { return .none } } + +extension UnknownJSONAPIError: Sampleable { + public static var sample: UnknownJSONAPIError { + return .unknownError + } +}