flagsmith-kotlin-android-client/FlagsmithClient/src/test/java/com/flagsmith/IdentityTests.kt at 0038652710685f29661cddbfe3b3cbf08751d00c · caselett/flagsmith-kotlin-android-client · GitHub

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
111
112
package com.flagsmith

import com.flagsmith.entities.Trait
import com.flagsmith.mockResponses.MockEndpoint
import com.flagsmith.mockResponses.MockResponses
import com.flagsmith.mockResponses.mockResponseFor
import kotlinx.coroutines.runBlocking
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import org.mockserver.integration.ClientAndServer
import org.mockserver.model.HttpRequest.request

class IdentityTests {

    private lateinit var mockServer: ClientAndServer
    private lateinit var flagsmith: Flagsmith

    @Before
    fun setup() {
        mockServer = ClientAndServer.startClientAndServer()
        flagsmith = Flagsmith(
            environmentKey = "",
            baseUrl = "http://localhost:${mockServer.localPort}",
            enableAnalytics = false,
            cacheConfig = FlagsmithCacheConfig(enableCache = false)
        )
    }

    @After
    fun tearDown() {
        mockServer.stop()
    }

    @Test
    fun testGetIdentity() {
        mockServer.mockResponseFor(MockEndpoint.GET_IDENTITIES)
        runBlocking {
            val result = flagsmith.getIdentitySync("person")

            mockServer.verify(
                request()
                    .withPath("/identities/")
                    .withMethod("GET")
                    .withQueryStringParameter("identifier", "person")
            )

            assertTrue(result.isSuccess)
            assertTrue(result.getOrThrow().traits.isNotEmpty())
            assertTrue(result.getOrThrow().flags.isNotEmpty())
            assertEquals(
                "electric pink",
                result.getOrThrow().traits.find { trait -> trait.key == "favourite-colour" }?.stringValue
            )
        }
    }

    @Test(expected = AssertionError::class)
    fun testGetIdentityWithExpectedParameterMissing() {
        mockServer.mockResponseFor(MockEndpoint.GET_IDENTITIES)
        runBlocking {
            flagsmith.getIdentitySync("person")

            mockServer.verify(
                request()
                    .withPath("/identities/")
                    .withMethod("GET")
                    .withQueryStringParameter("transient")
            )
        }
    }

    @Test
    fun testGetIdentityWithoutTransientParameter() {
        mockServer.mockResponseFor(MockEndpoint.GET_IDENTITIES)
        runBlocking {
            flagsmith.getIdentitySync("person")
            val requests = mockServer.retrieveRecordedRequests(
                request()
                    .withPath("/identities/")
                    .withMethod("GET")
            )
            assertEquals(1, requests.size)
            val request = requests[0]
            val transientParam = request.queryStringParameterList.find { it.name.toString() == "transient" }
            assertNull("transient parameter should not be present", transientParam)
        }
    }

    @Test
    fun testGetTransientIdentity() {
        mockServer.mockResponseFor(MockEndpoint.GET_TRANSIENT_IDENTITIES)
        runBlocking {
            val result = flagsmith.getIdentitySync("transient-identity", true)

            mockServer.verify(
                request()
                    .withPath("/identities/")
                    .withMethod("GET")
                    .withQueryStringParameter("identifier", "transient-identity")
                    .withQueryStringParameter("transient", "true")
            )

            assertTrue(result.isSuccess)
            assertTrue(result.getOrThrow().traits.isEmpty())
            assertTrue(result.getOrThrow().flags.isNotEmpty())
        }
    }
}