-
Notifications
You must be signed in to change notification settings - Fork 146
/
EnumBsonHandlerSpec.scala
110 lines (95 loc) · 3.23 KB
/
EnumBsonHandlerSpec.scala
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
package enumeratum
import org.scalatest.OptionValues._
import org.scalatest.{ FunSpec, Matchers }
import reactivemongo.bson._
/**
*
* @author Alessandro Lacava (@lambdista)
* @since 2016-04-23
*/
class EnumBsonHandlerSpec extends FunSpec with Matchers {
testScenario(
descriptor = "normal operation (no transformations)",
reader = EnumHandler.reader(Dummy),
expectedReadSuccesses = Map("A" -> Dummy.A, "c" -> Dummy.c),
expectedReadFails = Seq("C"),
writer = EnumHandler.writer(Dummy),
expectedWrites = Map(Dummy.A -> "A", Dummy.c -> "c"),
handler = EnumHandler.handler(Dummy)
)
testScenario(
descriptor = "case insensitive",
reader = EnumHandler.reader(enum = Dummy, insensitive = true),
expectedReadSuccesses = Map("A" -> Dummy.A, "a" -> Dummy.A, "C" -> Dummy.c),
expectedReadFails = Nil,
writer = EnumHandler.writer(Dummy),
expectedWrites = Map(Dummy.A -> "A", Dummy.c -> "c"),
handler = EnumHandler.handler(Dummy, insensitive = true)
)
testScenario(
descriptor = "lower case transformed",
reader = EnumHandler.readerLowercaseOnly(Dummy),
expectedReadSuccesses = Map("a" -> Dummy.A, "b" -> Dummy.B, "c" -> Dummy.c),
expectedReadFails = Seq("A", "B", "C"),
writer = EnumHandler.writerLowercase(Dummy),
expectedWrites = Map(Dummy.A -> "a", Dummy.c -> "c"),
handler = EnumHandler.handlerLowercaseOnly(Dummy)
)
testScenario(
descriptor = "upper case transformed",
reader = EnumHandler.readerUppercaseOnly(Dummy),
expectedReadSuccesses = Map("A" -> Dummy.A, "B" -> Dummy.B, "C" -> Dummy.c),
expectedReadFails = Seq("c"),
writer = EnumHandler.writerUppercase(Dummy),
expectedWrites = Map(Dummy.A -> "A", Dummy.c -> "C"),
handler = EnumHandler.handlerUppercaseOnly(Dummy)
)
private def testScenario(
descriptor: String,
reader: BSONReader[BSONValue, Dummy],
expectedReadSuccesses: Map[String, Dummy],
expectedReadFails: Seq[String],
writer: BSONWriter[Dummy, BSONValue],
expectedWrites: Map[Dummy, String],
handler: BSONHandler[BSONValue, Dummy]
): Unit = describe(descriptor) {
val expectedReadErrors = {
expectedReadFails.map(BSONString) ++ Seq(BSONString("D"), BSONInteger(2))
}
def readTests(theReader: BSONReader[BSONValue, Dummy]): Unit = {
it("should work with valid values") {
expectedReadSuccesses.foreach {
case (k, v) =>
theReader.readOpt(BSONString(k)).value shouldBe v
}
}
it("should fail with invalid values") {
expectedReadErrors.foreach { v =>
theReader.readOpt(v).isEmpty shouldBe true
}
}
}
def writeTests(theWriter: BSONWriter[Dummy, BSONValue]): Unit = {
it("should write enum values to BSONString") {
expectedWrites.foreach {
case (k, v) =>
writer.write(k) shouldBe BSONString(v)
}
}
}
describe("BSONReader") {
readTests(reader)
}
describe("BSONWriter") {
writeTests(writer)
}
describe("BJSONHandler") {
describe("reading") {
readTests(handler)
}
describe("writing") {
writeTests(handler)
}
}
}
}